Release v6.0.2

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

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

.github/workflows/backport-bot.yml

@@ -3,8 +3,6 @@ name: Backport Bot
 on:
   issues:
     types: [labeled]
-  pull_request:
-    types: [labeled]
   push:
     branches:
       - '*.x'
@@ -15,16 +13,13 @@ jobs:
     permissions:
       contents: read
       issues: write
-      pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Java
-        uses: actions/setup-java@v4
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
         with:
-          distribution: 'liberica'
-          java-version: 17
+          distribution: 'temurin'
+          java-version: '17'
       - name: Download BackportBot
         run: wget https://github.com/spring-io/backport-bot/releases/download/latest/backport-bot-0.0.1-SNAPSHOT.jar
       - name: Backport

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

@@ -1,63 +0,0 @@
-name: Build and deploy snapshot
-on:
-  push:
-    branches:
-      - 6.0.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  build-and-deploy-snapshot:
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    name: Build and deploy snapshot
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: 17
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Gradle
-        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
-        with:
-          cache-read-only: false
-      - name: Configure Gradle properties
-        shell: bash
-        run: |
-          mkdir -p $HOME/.gradle
-          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
-          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
-      - name: Build and publish
-        id: build
-        env:
-          CI: 'true'
-          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
-          DEVELOCITY_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-        run: ./gradlew -PdeploymentRepository=$(pwd)/deployment-repository build publishAllPublicationsToDeploymentRepository
-      - name: Deploy
-        uses: spring-io/artifactory-deploy-action@v0.0.1
-        with:
-          uri: 'https://repo.spring.io'
-          username: ${{ secrets.ARTIFACTORY_USERNAME }}
-          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-          build-name: ${{ format('spring-framework-{0}', github.ref_name)}}
-          repository: 'libs-snapshot-local'
-          folder: 'deployment-repository'
-          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
-          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          artifact-properties: |
-            /**/framework-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.outputs.build-scan-url }}
-          run-name: ${{ format('{0} | Linux | Java 17', github.ref_name) }}

.github/workflows/ci.yml

@@ -1,78 +0,0 @@
-name: CI
-on:
-  push:
-    branches:
-      - 6.0.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  ci:
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    strategy:
-      matrix:
-        os:
-          - id: ubuntu-latest
-            name: Linux
-        java:
-          - version: 17
-            toolchain: false
-          - version: 21
-            toolchain: true
-        exclude:
-          - os:
-              name: Linux
-            java:
-              version: 17
-    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
-    runs-on: ${{ matrix.os.id }}
-    steps:
-      - name: Set up Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: |
-            ${{ matrix.java.version }}
-            ${{ matrix.java.toolchain && '17' || '' }}
-      - name: Prepare Windows runner
-        if: ${{ runner.os == 'Windows' }}
-        run: |
-          git config --global core.autocrlf true
-          git config --global core.longPaths true
-          Stop-Service -name Docker
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Gradle
-        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
-        with:
-          cache-read-only: false
-      - name: Configure Gradle properties
-        shell: bash
-        run: |
-          mkdir -p $HOME/.gradle
-          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
-          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
-      - name: Configure toolchain properties
-        if: ${{ matrix.java.toolchain }}
-        shell: bash
-        run: |
-          echo toolchainVersion=${{ matrix.java.version }} >> $HOME/.gradle/gradle.properties
-          echo systemProp.org.gradle.java.installations.auto-detect=false >> $HOME/.gradle/gradle.properties
-          echo systemProp.org.gradle.java.installations.auto-download=false >> $HOME/.gradle/gradle.properties
-          echo systemProp.org.gradle.java.installations.paths=${{ format('$JAVA_HOME_{0}_X64', matrix.java.version) }} >> $HOME/.gradle/gradle.properties
-      - name: Build
-        id: build
-        env:
-          CI: 'true'
-          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
-          DEVELOCITY_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-        run: ./gradlew check antora
-      - name: Send notification
-        uses: ./.github/actions/send-notification
-        if: always()
-        with:
-          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-          status: ${{ job.status }}
-          build-scan-url: ${{ steps.build.outputs.build-scan-url }}
-          run-name: ${{ format('{0} | {1} | Java {2}', github.ref_name, matrix.os.name, matrix.java.version) }}

.github/workflows/deploy-docs.yml

@@ -1,34 +0,0 @@
-name: Deploy Docs
-on:
-  push:
-    branches:
-      - 'main'
-      - '*.x'
-      - '!gh-pages'
-    tags:
-      - 'v*'
-  repository_dispatch:
-    types: request-build-reference # legacy
-  workflow_dispatch:
-permissions:
-  actions: write
-jobs:
-  build:
-    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

@@ -9,5 +9,5 @@ jobs:
     name: "Validation"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: gradle/wrapper-validation-action@v2
+      - uses: actions/checkout@v3
+      - uses: gradle/wrapper-validation-action@v1

.gitignore

@@ -21,14 +21,15 @@ derby.log
 /build
 buildSrc/build
 /spring-*/build
-/framework-*/build
+/framework-bom/build
+/framework-docs/build
 /integration-tests/build
 /src/asciidoc/build
 spring-test/test-output/
 
 # Maven artifacts
 pom.xml
-/target/
+target/
 
 # Eclipse artifacts, including WTP generated manifests
 bin
@@ -49,7 +50,3 @@ atlassian-ide-plugin.xml
 
 # VS Code
 .vscode/
-
-cached-antora-playbook.yml
-
-node_modules

.mailmap

@@ -0,0 +1,34 @@
+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>
+<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.11-librca
+java=17.0.5-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://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)
+# <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-5.3.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-5.3.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
 
 This is the home of the Spring Framework: the foundation for all [Spring projects](https://spring.io/projects). Collectively the Spring Framework and the family of Spring projects are often referred to simply as "Spring". 
 

SECURITY.md

@@ -1,10 +1,5 @@
 # Security Policy
 
-## JAR signing
-
-Spring Framework JARs released on Maven Central are signed.
-You'll find more information about the key here: https://spring.io/GPG-KEY-spring.txt
-
 ## Supported Versions
 
 Please see the

build.gradle

@@ -1,14 +1,16 @@
 plugins {
-	id 'io.spring.nohttp' version '0.0.11'
-	id 'io.freefair.aspectj' version '8.0.1' apply false
+	id 'io.spring.nohttp' version '0.0.10'
+	id 'io.freefair.aspectj' version '6.5.0.3' 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.20'
+	id 'org.jetbrains.dokka' version '1.7.20'
+	id 'org.asciidoctor.jvm.convert' version '3.3.2' apply false
+	id 'org.asciidoctor.jvm.pdf' version '3.3.2'  apply false
 	id 'org.unbroken-dome.xjc' version '2.0.0' apply false
-	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.2' apply false
+	id 'com.github.ben-manes.versions' version '0.42.0'
+	id 'com.github.johnrengelman.shadow' version '7.1.2' apply false
+	id 'de.undercouch.download' version '5.1.0'
+	id 'me.champeau.jmh' version '0.6.6' apply false
 }
 
 ext {
@@ -26,6 +28,7 @@ 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" }
 		}
@@ -75,7 +78,7 @@ configure([rootProject] + javaProjects) { project ->
 	}
 
 	checkstyle {
-		toolVersion = "10.12.7"
+		toolVersion = "10.4"
 		configDirectory.set(rootProject.file("src/checkstyle"))
 	}
 
@@ -102,35 +105,42 @@ configure([rootProject] + javaProjects) { project ->
 		testRuntimeOnly("org.junit.platform:junit-platform-suite-engine")
 		testRuntimeOnly("org.apache.logging.log4j:log4j-core")
 		testRuntimeOnly("org.apache.logging.log4j:log4j-jul")
-		testRuntimeOnly("org.apache.logging.log4j:log4j-slf4j2-impl")
+		testRuntimeOnly("org.apache.logging.log4j:log4j-slf4j-impl")
 		// 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.41")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.31")
 	}
 
 	ext.javadocLinks = [
 			"https://docs.oracle.com/en/java/javase/17/docs/api/",
 			"https://jakarta.ee/specifications/platform/9/apidocs/",
-			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
-			"https://eclipse.dev/aspectj/doc/released/aspectj5rt-api",
+			"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://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/",
-			"https://www.javadoc.io/doc/com.fasterxml.jackson.dataformat/jackson-dataformat-xml/2.14.1/",
+			"https://fasterxml.github.io/jackson-core/javadoc/2.10/",
+			"https://fasterxml.github.io/jackson-databind/javadoc/2.10/",
+			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.10/",
 			"https://hc.apache.org/httpcomponents-client-5.2.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
-			// TODO Uncomment link to JUnit 5 docs once we execute Gradle with Java 18+.
-			// See https://github.com/spring-projects/spring-framework/issues/27497
+			// TODO Uncomment link to JUnit 5 docs once we have sorted out
+			// the following warning in the build.
 			//
-			// "https://junit.org/junit5/docs/5.9.3/api/",
+			// warning: The code being documented uses packages in the unnamed module, but the packages defined in https://junit.org/junit5/docs/5.9.1/api/ are in named modules.
+			//
+			// "https://junit.org/junit5/docs/5.9.1/api/",
 			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
 			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
-			// 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.
+			// 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.
 			"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/"
 	] as String[]
 }
@@ -143,10 +153,10 @@ 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"

buildSrc/README.md

@@ -22,6 +22,21 @@ 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,11 +19,16 @@ ext {
 dependencies {
 	implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
 	implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}")
-	implementation "org.gradle:test-retry-gradle-plugin:1.5.6"
+	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.3.0"
+	implementation "org.gradle:test-retry-gradle-plugin:1.4.1"
 }
 
 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/TestConventions.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,8 +26,8 @@ import org.gradle.testretry.TestRetryTaskExtension;
  * Conventions that are applied in the presence of the {@link JavaBasePlugin}. When the
  * plugin is applied:
  * <ul>
- * <li>The {@link TestRetryPlugin Test Retry} plugin is applied so that flaky tests
- * are retried 3 times when running on the CI server.
+ * <li>The {@link TestRetryPlugin Test Retry} plugins is applied so that flaky tests
+ * are retried 3 times when running on the CI.
  * </ul>
  *
  * @author Brian Clozel
@@ -40,8 +40,9 @@ class TestConventions {
 	}
 
 	private void configureTestConventions(Project project) {
+		project.getPlugins().apply(TestRetryPlugin.class);
 		project.getTasks().withType(Test.class,
-				test -> project.getPlugins().withType(TestRetryPlugin.class, testRetryPlugin -> {
+				(test) -> project.getPlugins().withType(TestRetryPlugin.class, (testRetryPlugin) -> {
 					TestRetryTaskExtension testRetry = test.getExtensions().getByType(TestRetryTaskExtension.class);
 					testRetry.getFailOnPassedAfterRetry().set(true);
 					testRetry.getMaxRetries().set(isCi() ? 3 : 0);

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

@@ -0,0 +1,140 @@
+/*
+ * 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,7 +1,5 @@
 == Spring Framework Concourse pipeline
 
-NOTE: CI is being migrated to GitHub Actions.
-
 The Spring Framework uses https://concourse-ci.org/[Concourse] for its CI build and other automated tasks.
 The Spring team has a dedicated Concourse instance available at https://ci.spring.io with a build pipeline
 for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x[Spring Framework 6.0.x].

ci/config/changelog-generator.yml

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

ci/images/ci-image/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:jammy-20240125
+FROM ubuntu:focal-20220922
 
 ADD setup.sh /setup.sh
 ADD get-jdk-url.sh /get-jdk-url.sh
@@ -6,5 +6,7 @@ RUN ./setup.sh
 
 ENV JAVA_HOME /opt/openjdk/java17
 ENV JDK17 /opt/openjdk/java17
+ENV JDK18 /opt/openjdk/java18
+ENV JDK19 /opt/openjdk/java19
 
 ENV PATH $JAVA_HOME/bin:$PATH

ci/images/get-jdk-url.sh

@@ -3,7 +3,13 @@ set -e
 
 case "$1" in
 	java17)
-		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.10%2B13/bellsoft-jdk17.0.10+13-linux-amd64.tar.gz"
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.5+8/bellsoft-jdk17.0.5+8-linux-amd64.tar.gz"
+	;;
+	java18)
+		echo "https://github.com/bell-sw/Liberica/releases/download/18.0.2.1%2B1/bellsoft-jdk18.0.2.1+1-linux-amd64.tar.gz"
+	;;
+	java19)
+		echo "https://github.com/bell-sw/Liberica/releases/download/19.0.1%2B11/bellsoft-jdk19.0.1+11-linux-amd64.tar.gz"
 	;;
 	*)
 		echo $"Unknown java version"

ci/images/setup.sh

@@ -20,7 +20,7 @@ curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/c
 
 mkdir -p /opt/openjdk
 pushd /opt/openjdk > /dev/null
-for jdk in java17
+for jdk in java17 java18 java19
 do
   JDK_URL=$( /get-jdk-url.sh $jdk )
   mkdir $jdk

ci/parameters.yml

@@ -3,8 +3,12 @@ github-repo-name: "spring-projects/spring-framework"
 sonatype-staging-profile: "org.springframework"
 docker-hub-organization: "springci"
 artifactory-server: "https://repo.spring.io"
-branch: "6.0.x"
+branch: "main"
 milestone: "6.0.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
 concourse-url: "https://ci.spring.io"
+registry-mirror-host: docker.repo.spring.io
+registry-mirror-username: ((artifactory-username))
+registry-mirror-password: ((artifactory-password))
+task-timeout: 1h00m

ci/pipeline.yml

@@ -5,7 +5,9 @@ anchors:
     password: ((github-ci-release-token))
     branch: ((branch))
   gradle-enterprise-task-params: &gradle-enterprise-task-params
-    DEVELOCITY_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
+    GRADLE_ENTERPRISE_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
+    GRADLE_ENTERPRISE_CACHE_USERNAME: ((gradle_enterprise_cache_user.username))
+    GRADLE_ENTERPRISE_CACHE_PASSWORD: ((gradle_enterprise_cache_user.password))
   sonatype-task-params: &sonatype-task-params
     SONATYPE_USERNAME: ((sonatype-username))
     SONATYPE_PASSWORD: ((sonatype-password))
@@ -21,6 +23,19 @@ anchors:
   docker-resource-source: &docker-resource-source
     username: ((docker-hub-username))
     password: ((docker-hub-password))
+    tag: ((milestone))
+  registry-mirror-vars: &registry-mirror-vars
+    registry-mirror-host: ((registry-mirror-host))
+    registry-mirror-username: ((registry-mirror-username))
+    registry-mirror-password: ((registry-mirror-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
@@ -33,27 +48,33 @@ resource_types:
 - name: registry-image
   type: registry-image
   source:
-    <<: *docker-resource-source
     repository: concourse/registry-image-resource
-    tag: 1.8.0
+    tag: 1.5.0
 - name: artifactory-resource
   type: registry-image
   source:
-    <<: *docker-resource-source
     repository: springio/artifactory-resource
-    tag: 0.0.18
+    tag: 0.0.17
 - name: github-release
   type: registry-image
   source:
-    <<: *docker-resource-source
     repository: concourse/github-release-resource
-    tag: 1.8.0
+    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:
+    repository: teliaoss/github-pr-resource
+    tag: v0.23.0
+- name: slack-notification
+  type: registry-image
+  source:
+    repository: cfcommunity/slack-notification-resource
+    tag: latest
 resources:
 - name: git-repo
   type: git
@@ -73,7 +94,13 @@ resources:
   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
@@ -82,6 +109,43 @@ resources:
     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-jdk18-build
+  type: github-status-resource
+  icon: eye-check-outline
+  source:
+    repository: ((github-repo-name))
+    access_token: ((github-ci-status-token))
+    branch: ((branch))
+    context: jdk18-build
+- name: repo-status-jdk19-build
+  type: github-status-resource
+  icon: eye-check-outline
+  source:
+    repository: ((github-repo-name))
+    access_token: ((github-ci-status-token))
+    branch: ((branch))
+    context: jdk19-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
@@ -112,27 +176,41 @@ jobs:
         image: ci-image
       vars:
         ci-image-name: ci-image
-        <<: *docker-resource-source
+        <<: *registry-mirror-vars
     - put: ci-image
       params:
         image: ci-image/image.tar
-- name: stage-milestone
+- name: build
   serial: true
+  public: 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
+    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-staging-local
+      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}"
@@ -157,9 +235,114 @@ jobs:
         - "/**/framework-docs-*-schema.zip"
         properties:
           "zip.type": "schema"
-  - put: git-repo
-    params:
-      repository: stage-git-repo
+    get_params:
+      threads: 8
+- name: jdk18-build
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: every-morning
+      trigger: true
+    - put: repo-status-jdk18-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: 18
+            <<: *build-project-task-params
+      on_failure:
+        do:
+          - put: repo-status-jdk18-build
+            params: { state: "failure", commit: "git-repo" }
+          - put: slack-alert
+            params:
+              <<: *slack-fail-params
+    - put: repo-status-jdk18-build
+      params: { state: "success", commit: "git-repo" }
+- name: jdk19-build
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: every-morning
+      trigger: true
+    - put: repo-status-jdk19-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: 19
+            <<: *build-project-task-params
+      on_failure:
+        do:
+          - put: repo-status-jdk19-build
+            params: { state: "failure", commit: "git-repo" }
+          - put: slack-alert
+            params:
+              <<: *slack-fail-params
+    - put: repo-status-jdk19-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:
@@ -182,7 +365,6 @@ jobs:
       params:
         RELEASE_TYPE: M
         <<: *github-task-params
-        <<: *docker-resource-source
     - put: github-pre-release
       params:
         <<: *changelog-task-params
@@ -201,6 +383,7 @@ jobs:
     - put: artifactory-repo
       params:
         <<: *artifactory-params
+        repo: libs-staging-local
     - put: git-repo
       params:
         repository: stage-git-repo
@@ -220,7 +403,6 @@ jobs:
       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
@@ -245,6 +427,7 @@ jobs:
     - put: artifactory-repo
       params:
         <<: *artifactory-params
+        repo: libs-staging-local
     - put: git-repo
       params:
         repository: stage-git-repo
@@ -264,7 +447,6 @@ jobs:
       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
@@ -282,14 +464,17 @@ jobs:
       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", "jdk18-build", "jdk19-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

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

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

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

ci/tasks/build-ci-image.yml

@@ -5,8 +5,10 @@ image_resource:
   source:
     repository: concourse/oci-build-task
     tag: 0.10.0
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
+    registry_mirror:
+      host: ((registry-mirror-host))
+      username: ((registry-mirror-username))
+      password: ((registry-mirror-password))
 inputs:
   - name: ci-images-git-repo
 outputs:

ci/tasks/build-pr.yml

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

ci/tasks/build-project.yml

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

ci/tasks/check-project.yml

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

ci/tasks/generate-changelog.yml

@@ -5,8 +5,6 @@ image_resource:
   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

ci/tasks/promote-version.yml

@@ -4,9 +4,7 @@ image_resource:
   type: registry-image
   source:
     repository: springio/concourse-release-scripts
-    tag: '0.4.0'
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
+    tag: '0.3.4'
 inputs:
 - name: git-repo
 - name: artifactory-repo

framework-docs/antora-playbook.yml

@@ -1,39 +0,0 @@
-antora:
-  extensions:
-  - require: '@springio/antora-extensions'
-    root_component_name: 'framework'
-site:
-  title: Spring Framework
-  url: https://docs.spring.io/spring-framework/reference
-  robots: allow
-git:
-  ensure_git_suffix: false
-content:
-  sources:
-  - url: https://github.com/spring-projects/spring-framework
-    # Refname matching:
-    # https://docs.antora.org/antora/latest/playbook/content-refname-matching/
-    branches: ['main', '{6..9}.+({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.15/ui-bundle.zip

framework-docs/antora.yml

@@ -1,32 +0,0 @@
-name: framework
-version: true
-title: Spring Framework
-nav:
-  - modules/ROOT/nav.adoc
-ext:
-  collector:
-    run:
-      command: gradlew -q -PbuildSrc.skipTests=true "-Dorg.gradle.jvmargs=-Xmx3g -XX:+HeapDumpOnOutOfMemoryError" :framework-docs:generateAntoraResources
-      local: true
-    scan:
-      dir: ./build/generated-antora-resources
-
-asciidoc:
-  attributes:
-    attribute-missing: 'warn'
-    # FIXME: the copyright is not removed
-    # FIXME: The package is not renamed
-    chomp: 'all'
-    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,39 +1,27 @@
-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"
 
 
-antora {
-	options = [clean: true, fetch: !project.gradle.startParameter.offline, stacktrace: true]
-	environment = [
-			'BUILD_REFNAME': 'HEAD',
-			'BUILD_VERSION': project.version,
-	]
+configurations {
+	asciidoctorExtensions
 }
 
+dependencies {
+	api(project(":spring-context"))
+	api(project(":spring-web"))
 
-tasks.named("generateAntoraYml") {
-	asciidocAttributes = project.provider( {
-		return  ["spring-version": project.version ]
-	} )
+	implementation(project(":spring-core-test"))
+	implementation("org.assertj:assertj-core")
 }
 
-tasks.create("generateAntoraResources") {
-	dependsOn 'generateAntoraYml'
+checkstyle {
+	sourceSets = []
 }
 
-// Commented out for now:
-// https://github.com/spring-projects/spring-framework/issues/30481
-// tasks.named("check") {
-//	dependsOn 'antora'
-// }
-
 jar {
 	enabled = false
 }
@@ -42,21 +30,16 @@ javadoc {
 	enabled = false
 }
 
+dependencies {
+	asciidoctorExtensions "io.spring.asciidoctor.backends:spring-asciidoctor-backends:0.0.3"
+}
+
 repositories {
 	maven {
 		url "https://repo.spring.io/release"
 	}
 }
 
-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")
-}
-
 /**
  * Produce Javadoc for all Spring Framework modules in "build/docs/javadoc"
  */
@@ -87,7 +70,7 @@ task api(type: Javadoc) {
 		overview = "framework-docs/src/docs/api/overview.html"
 		splitIndex = true
 		links(project.ext.javadocLinks)
-		addBooleanOption('Xdoclint:syntax,reference', true) // only check syntax and reference with doclint
+		addBooleanOption('Xdoclint:syntax', true) // only check syntax with doclint
 		addBooleanOption('Werror', true) // fail build on Javadoc warnings
 	}
 	source moduleProjects.collect { project ->
@@ -108,10 +91,64 @@ 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
+	])
+}
+
 /**
- * Zip all Java docs (javadoc & kdoc) into a single archive
+ * Generate the Spring Framework Reference documentation from
+ * "src/docs/asciidoc" in "build/docs/ref-docs/html5".
  */
-task docsZip(type: Zip, dependsOn: ['api', rootProject.tasks.dokkaHtmlMultiModule]) {
+asciidoctor {
+	baseDirFollowsSourceDir()
+	configurations "asciidoctorExtensions"
+	sources {
+		include '*.adoc'
+	}
+	outputDir "$buildDir/docs/ref-docs/html5"
+	outputOptions {
+		backends "spring-html"
+	}
+	logDocuments = true
+	resources {
+		from(sourceDir) {
+			include 'images/*.png'
+		}
+	}
+}
+
+/**
+ * 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]) {
 	group = "Distribution"
 	description = "Builds -${archiveClassifier} archive containing api and reference " +
 			"for deployment at https://docs.spring.io/spring-framework/docs/."
@@ -124,6 +161,12 @@ task docsZip(type: Zip, dependsOn: ['api', rootProject.tasks.dokkaHtmlMultiModul
 	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"
 	}
@@ -204,6 +247,7 @@ task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
 
 distZip.mustRunAfter moduleProjects.check
 
+
 publishing {
 	publications {
 		mavenJava(MavenPublication) {

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

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

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

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

framework-docs/modules/ROOT/nav.adoc

@@ -1,434 +0,0 @@
-* xref:overview.adoc[Overview]
-* xref:core.adoc[]
-** xref:core/beans.adoc[]
-*** xref:core/beans/introduction.adoc[]
-*** xref:core/beans/basics.adoc[]
-*** xref:core/beans/definition.adoc[]
-*** xref:core/beans/dependencies.adoc[]
-**** xref:core/beans/dependencies/factory-collaborators.adoc[]
-**** xref:core/beans/dependencies/factory-properties-detailed.adoc[]
-**** xref:core/beans/dependencies/factory-dependson.adoc[]
-**** xref:core/beans/dependencies/factory-lazy-init.adoc[]
-**** xref:core/beans/dependencies/factory-autowire.adoc[]
-**** xref:core/beans/dependencies/factory-method-injection.adoc[]
-*** xref:core/beans/factory-scopes.adoc[]
-*** xref:core/beans/factory-nature.adoc[]
-*** xref:core/beans/child-bean-definitions.adoc[]
-*** xref:core/beans/factory-extension.adoc[]
-*** xref:core/beans/annotation-config.adoc[]
-**** xref:core/beans/annotation-config/autowired.adoc[]
-**** xref:core/beans/annotation-config/autowired-primary.adoc[]
-**** xref:core/beans/annotation-config/autowired-qualifiers.adoc[]
-**** xref:core/beans/annotation-config/generics-as-qualifiers.adoc[]
-**** xref:core/beans/annotation-config/custom-autowire-configurer.adoc[]
-**** xref:core/beans/annotation-config/resource.adoc[]
-**** xref:core/beans/annotation-config/value-annotations.adoc[]
-**** xref:core/beans/annotation-config/postconstruct-and-predestroy-annotations.adoc[]
-*** xref:core/beans/classpath-scanning.adoc[]
-*** xref:core/beans/standard-annotations.adoc[]
-*** xref:core/beans/java.adoc[]
-**** xref:core/beans/java/basic-concepts.adoc[]
-**** xref:core/beans/java/instantiating-container.adoc[]
-**** xref:core/beans/java/bean-annotation.adoc[]
-**** xref:core/beans/java/configuration-annotation.adoc[]
-**** xref:core/beans/java/composing-configuration-classes.adoc[]
-*** xref:core/beans/environment.adoc[]
-*** xref:core/beans/context-load-time-weaver.adoc[]
-*** xref:core/beans/context-introduction.adoc[]
-*** xref:core/beans/beanfactory.adoc[]
-** xref:core/resources.adoc[]
-** xref:core/validation.adoc[]
-*** xref:core/validation/validator.adoc[]
-*** xref:core/validation/beans-beans.adoc[]
-*** xref:core/validation/conversion.adoc[]
-*** xref:core/validation/convert.adoc[]
-*** xref:core/validation/format.adoc[]
-*** xref:core/validation/format-configuring-formatting-globaldatetimeformat.adoc[]
-*** xref:core/validation/beanvalidation.adoc[]
-** xref:core/expressions.adoc[]
-*** xref:core/expressions/evaluation.adoc[]
-*** xref:core/expressions/beandef.adoc[]
-*** xref:core/expressions/language-ref.adoc[]
-**** xref:core/expressions/language-ref/literal.adoc[]
-**** xref:core/expressions/language-ref/properties-arrays.adoc[]
-**** xref:core/expressions/language-ref/inline-lists.adoc[]
-**** xref:core/expressions/language-ref/inline-maps.adoc[]
-**** xref:core/expressions/language-ref/array-construction.adoc[]
-**** xref:core/expressions/language-ref/methods.adoc[]
-**** xref:core/expressions/language-ref/operators.adoc[]
-**** xref:core/expressions/language-ref/types.adoc[]
-**** xref:core/expressions/language-ref/constructors.adoc[]
-**** xref:core/expressions/language-ref/variables.adoc[]
-**** xref:core/expressions/language-ref/functions.adoc[]
-**** xref:core/expressions/language-ref/bean-references.adoc[]
-**** xref:core/expressions/language-ref/operator-ternary.adoc[]
-**** xref:core/expressions/language-ref/operator-elvis.adoc[]
-**** xref:core/expressions/language-ref/operator-safe-navigation.adoc[]
-**** xref:core/expressions/language-ref/collection-selection.adoc[]
-**** xref:core/expressions/language-ref/collection-projection.adoc[]
-**** xref:core/expressions/language-ref/templating.adoc[]
-*** xref:core/expressions/example-classes.adoc[]
-** xref:core/aop.adoc[]
-*** xref:core/aop/introduction-defn.adoc[]
-*** xref:core/aop/introduction-spring-defn.adoc[]
-*** xref:core/aop/introduction-proxies.adoc[]
-*** xref:core/aop/ataspectj.adoc[]
-**** xref:core/aop/ataspectj/aspectj-support.adoc[]
-**** xref:core/aop/ataspectj/at-aspectj.adoc[]
-**** xref:core/aop/ataspectj/pointcuts.adoc[]
-**** xref:core/aop/ataspectj/advice.adoc[]
-**** xref:core/aop/ataspectj/introductions.adoc[]
-**** xref:core/aop/ataspectj/instantiation-models.adoc[]
-**** xref:core/aop/ataspectj/example.adoc[]
-*** xref:core/aop/schema.adoc[]
-*** xref:core/aop/choosing.adoc[]
-*** xref:core/aop/mixing-styles.adoc[]
-*** xref:core/aop/proxying.adoc[]
-*** xref:core/aop/aspectj-programmatic.adoc[]
-*** xref:core/aop/using-aspectj.adoc[]
-*** xref:core/aop/resources.adoc[]
-** xref:core/aop-api.adoc[]
-*** xref:core/aop-api/pointcuts.adoc[]
-*** xref:core/aop-api/advice.adoc[]
-*** xref:core/aop-api/advisor.adoc[]
-*** xref:core/aop-api/pfb.adoc[]
-*** xref:core/aop-api/concise-proxy.adoc[]
-*** xref:core/aop-api/prog.adoc[]
-*** xref:core/aop-api/advised.adoc[]
-*** xref:core/aop-api/autoproxy.adoc[]
-*** xref:core/aop-api/targetsource.adoc[]
-*** xref:core/aop-api/extensibility.adoc[]
-** xref:core/null-safety.adoc[]
-** xref:core/databuffer-codec.adoc[]
-** xref:core/spring-jcl.adoc[]
-** xref:core/aot.adoc[]
-** xref:core/appendix.adoc[]
-*** xref:core/appendix/xsd-schemas.adoc[]
-*** xref:core/appendix/xml-custom.adoc[]
-*** xref:core/appendix/application-startup-steps.adoc[]
-* xref:testing.adoc[]
-** xref:testing/introduction.adoc[]
-** xref:testing/unit.adoc[]
-** xref:testing/integration.adoc[]
-** xref:testing/support-jdbc.adoc[]
-** xref:testing/testcontext-framework.adoc[]
-*** xref:testing/testcontext-framework/key-abstractions.adoc[]
-*** xref:testing/testcontext-framework/bootstrapping.adoc[]
-*** xref:testing/testcontext-framework/tel-config.adoc[]
-*** xref:testing/testcontext-framework/application-events.adoc[]
-*** xref:testing/testcontext-framework/test-execution-events.adoc[]
-*** xref:testing/testcontext-framework/ctx-management.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/xml.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/groovy.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/mixed-config.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/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/core/aop-api.adoc

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,232 +0,0 @@
-[[aop-targetsource]]
-= Using `TargetSource` Implementations
-
-Spring offers the concept of a `TargetSource`, expressed in the
-`org.springframework.aop.TargetSource` interface. This interface is responsible for
-returning the "`target object`" that implements the join point. The `TargetSource`
-implementation is asked for a target instance each time the AOP proxy handles a method
-invocation.
-
-Developers who use Spring AOP do not normally need to work directly with `TargetSource` implementations, but
-this provides a powerful means of supporting pooling, hot swappable, and other
-sophisticated targets. For example, a pooling `TargetSource` can return a different target
-instance for each invocation, by using a pool to manage instances.
-
-If you do not specify a `TargetSource`, a default implementation is used to wrap a
-local object. The same target is returned for each invocation (as you would expect).
-
-The rest of this section describes the standard target sources provided with Spring and how you can use them.
-
-TIP: When using a custom target source, your target will usually need to be a prototype
-rather than a singleton bean definition. This allows Spring to create a new target
-instance when required.
-
-
-
-[[aop-ts-swap]]
-== Hot-swappable Target Sources
-
-The `org.springframework.aop.target.HotSwappableTargetSource` exists to let the target
-of an AOP proxy be switched while letting callers keep their references to it.
-
-Changing the target source's target takes effect immediately. The
-`HotSwappableTargetSource` is thread-safe.
-
-You can change the target by using the `swap()` method on HotSwappableTargetSource, as the follow example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	HotSwappableTargetSource swapper = (HotSwappableTargetSource) beanFactory.getBean("swapper");
-	Object oldTarget = swapper.swap(newTarget);
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val swapper = beanFactory.getBean("swapper") as HotSwappableTargetSource
-	val oldTarget = swapper.swap(newTarget)
-----
-======
-
-The following example shows the required XML definitions:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="initialTarget" class="mycompany.OldTarget"/>
-
-	<bean id="swapper" class="org.springframework.aop.target.HotSwappableTargetSource">
-		<constructor-arg ref="initialTarget"/>
-	</bean>
-
-	<bean id="swappable" class="org.springframework.aop.framework.ProxyFactoryBean">
-		<property name="targetSource" ref="swapper"/>
-	</bean>
-----
-
-The preceding `swap()` call changes the target of the swappable bean. Clients that hold a
-reference to that bean are unaware of the change but immediately start hitting
-the new target.
-
-Although this example does not add any advice (it is not necessary to add advice to
-use a `TargetSource`), any `TargetSource` can be used in conjunction with
-arbitrary advice.
-
-
-
-[[aop-ts-pool]]
-== Pooling Target Sources
-
-Using a pooling target source provides a similar programming model to stateless session
-EJBs, in which a pool of identical instances is maintained, with method invocations
-going to free objects in the pool.
-
-A crucial difference between Spring pooling and SLSB pooling is that Spring pooling can
-be applied to any POJO. As with Spring in general, this service can be applied in a
-non-invasive way.
-
-Spring provides support for Commons Pool 2.2, which provides a
-fairly efficient pooling implementation. You need the `commons-pool` Jar on your
-application's classpath to use this feature. You can also subclass
-`org.springframework.aop.target.AbstractPoolingTargetSource` to support any other
-pooling API.
-
-NOTE: Commons Pool 1.5+ is also supported but is deprecated as of Spring Framework 4.2.
-
-The following listing shows an example configuration:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="businessObjectTarget" class="com.mycompany.MyBusinessObject"
-			scope="prototype">
-		... properties omitted
-	</bean>
-
-	<bean id="poolTargetSource" class="org.springframework.aop.target.CommonsPool2TargetSource">
-		<property name="targetBeanName" value="businessObjectTarget"/>
-		<property name="maxSize" value="25"/>
-	</bean>
-
-	<bean id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">
-		<property name="targetSource" ref="poolTargetSource"/>
-		<property name="interceptorNames" value="myInterceptor"/>
-	</bean>
-----
-
-Note that the target object (`businessObjectTarget` in the preceding example) must be a
-prototype. This lets the `PoolingTargetSource` implementation create new instances
-of the target to grow the pool as necessary. See the {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

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

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

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

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

@@ -1,16 +0,0 @@
-[[aop-ataspectj]]
-= @AspectJ support
-:page-section-summary-toc: 1
-
-@AspectJ refers to a style of declaring aspects as regular Java classes annotated with
-annotations. The @AspectJ style was introduced by the
-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

@@ -1,946 +0,0 @@
-[[aop-advice]]
-= Declaring Advice
-
-Advice is associated with a pointcut expression and runs before, after, or around method
-executions matched by the pointcut. The pointcut expression may be either an _inline
-pointcut_ or a reference to a xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[_named pointcut_].
-
-
-[[aop-advice-before]]
-== Before Advice
-
-You can declare before advice in an aspect by using the `@Before` annotation.
-
-The following example uses an inline pointcut expression.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.Before;
-
-	@Aspect
-	public class BeforeExample {
-
-		@Before("execution(* com.xyz.dao.*.*(..))")
-		public void doAccessCheck() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.Before
-
-	@Aspect
-	class BeforeExample {
-
-		@Before("execution(* com.xyz.dao.*.*(..))")
-		fun doAccessCheck() {
-			// ...
-		}
-	}
-----
-======
-
-If we use a xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[named pointcut], we can rewrite the preceding example
-as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.Before;
-
-	@Aspect
-	public class BeforeExample {
-
-		@Before("com.xyz.CommonPointcuts.dataAccessOperation()")
-		public void doAccessCheck() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.Before
-
-	@Aspect
-	class BeforeExample {
-
-		@Before("com.xyz.CommonPointcuts.dataAccessOperation()")
-		fun doAccessCheck() {
-			// ...
-		}
-	}
-----
-======
-
-
-[[aop-advice-after-returning]]
-== After Returning Advice
-
-After returning advice runs when a matched method execution returns normally.
-You can declare it by using the `@AfterReturning` annotation.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.AfterReturning;
-
-	@Aspect
-	public class AfterReturningExample {
-
-		@AfterReturning("execution(* com.xyz.dao.*.*(..))")
-		public void doAccessCheck() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.AfterReturning
-
-	@Aspect
-	class AfterReturningExample {
-
-		@AfterReturning("execution(* com.xyz.dao.*.*(..))")
-		fun doAccessCheck() {
-			// ...
-		}
-	}
-----
-======
-
-NOTE: You can have multiple advice declarations (and other members as well),
-all inside the same aspect. We show only a single advice declaration in these
-examples to focus the effect of each one.
-
-Sometimes, you need access in the advice body to the actual value that was returned.
-You can use the form of `@AfterReturning` that binds the return value to get that
-access, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.AfterReturning;
-
-	@Aspect
-	public class AfterReturningExample {
-
-		@AfterReturning(
-			pointcut="execution(* com.xyz.dao.*.*(..))",
-			returning="retVal")
-		public void doAccessCheck(Object retVal) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.AfterReturning
-
-	@Aspect
-	class AfterReturningExample {
-
-		@AfterReturning(
-			pointcut = "execution(* com.xyz.dao.*.*(..))",
-			returning = "retVal")
-		fun doAccessCheck(retVal: Any?) {
-			// ...
-		}
-	}
-----
-======
-
-The name used in the `returning` attribute must correspond to the name of a parameter
-in the advice method. When a method execution returns, the return value is passed to
-the advice method as the corresponding argument value. A `returning` clause also
-restricts matching to only those method executions that return a value of the
-specified type (in this case, `Object`, which matches any return value).
-
-Please note that it is not possible to return a totally different reference when
-using after returning advice.
-
-
-[[aop-advice-after-throwing]]
-== After Throwing Advice
-
-After throwing advice runs when a matched method execution exits by throwing an
-exception. You can declare it by using the `@AfterThrowing` annotation, as the
-following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.AfterThrowing;
-
-	@Aspect
-	public class AfterThrowingExample {
-
-		@AfterThrowing("execution(* com.xyz.dao.*.*(..))")
-		public void doRecoveryActions() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.AfterThrowing
-
-	@Aspect
-	class AfterThrowingExample {
-
-		@AfterThrowing("execution(* com.xyz.dao.*.*(..))")
-		fun doRecoveryActions() {
-			// ...
-		}
-	}
-----
-======
-
-Often, you want the advice to run only when exceptions of a given type are thrown,
-and you also often need access to the thrown exception in the advice body. You can
-use the `throwing` attribute to both restrict matching (if desired -- use `Throwable`
-as the exception type otherwise) and bind the thrown exception to an advice parameter.
-The following example shows how to do so:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.AfterThrowing;
-
-	@Aspect
-	public class AfterThrowingExample {
-
-		@AfterThrowing(
-			pointcut="execution(* com.xyz.dao.*.*(..))",
-			throwing="ex")
-		public void doRecoveryActions(DataAccessException ex) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.AfterThrowing
-
-	@Aspect
-	class AfterThrowingExample {
-
-		@AfterThrowing(
-			pointcut = "execution(* com.xyz.dao.*.*(..))",
-			throwing = "ex")
-		fun doRecoveryActions(ex: DataAccessException) {
-			// ...
-		}
-	}
-----
-======
-
-The name used in the `throwing` attribute must correspond to the name of a parameter in
-the advice method. When a method execution exits by throwing an exception, the exception
-is passed to the advice method as the corresponding argument value. A `throwing` clause
-also restricts matching to only those method executions that throw an exception of the
-specified type (`DataAccessException`, in this case).
-
-[NOTE]
-====
-Note that `@AfterThrowing` does not indicate a general exception handling callback.
-Specifically, an `@AfterThrowing` advice method is only supposed to receive exceptions
-from the join point (user-declared target method) itself but not from an accompanying
-`@After`/`@AfterReturning` method.
-====
-
-
-[[aop-advice-after-finally]]
-== After (Finally) Advice
-
-After (finally) advice runs when a matched method execution exits. It is declared by
-using the `@After` annotation. After advice must be prepared to handle both normal and
-exception return conditions. It is typically used for releasing resources and similar
-purposes. The following example shows how to use after finally advice:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.After;
-
-	@Aspect
-	public class AfterFinallyExample {
-
-		@After("execution(* com.xyz.dao.*.*(..))")
-		public void doReleaseLock() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.After
-
-	@Aspect
-	class AfterFinallyExample {
-
-		@After("execution(* com.xyz.dao.*.*(..))")
-		fun doReleaseLock() {
-			// ...
-		}
-	}
-----
-======
-
-[NOTE]
-====
-Note that `@After` advice in AspectJ is defined as "after finally advice", analogous
-to a finally block in a try-catch statement. It will be invoked for any outcome,
-normal return or exception thrown from the join point (user-declared target method),
-in contrast to `@AfterReturning` which only applies to successful normal returns.
-====
-
-
-[[aop-ataspectj-around-advice]]
-== Around Advice
-
-The last kind of advice is _around_ advice. Around advice runs "around" a matched
-method's execution. It has the opportunity to do work both before and after the method
-runs and to determine when, how, and even if the method actually gets to run at all.
-Around advice is often used if you need to share state before and after a method
-execution in a thread-safe manner – for example, starting and stopping a timer.
-
-[TIP]
-====
-Always use the least powerful form of advice that meets your requirements.
-
-For example, do not use _around_ advice if _before_ advice is sufficient for your needs.
-====
-
-Around advice is declared by annotating a method with the `@Around` annotation. The
-method should declare `Object` as its return type, and the first parameter of the method
-must be of type `ProceedingJoinPoint`. Within the body of the advice method, you must
-invoke `proceed()` on the `ProceedingJoinPoint` in order for the underlying method to
-run. Invoking `proceed()` without arguments will result in the caller's original
-arguments being supplied to the underlying method when it is invoked. For advanced use
-cases, there is an overloaded variant of the `proceed()` method which accepts an array of
-arguments (`Object[]`). The values in the array will be used as the arguments to the
-underlying method when it is invoked.
-
-[NOTE]
-====
-The behavior of `proceed` when called with an `Object[]` is a little different than the
-behavior of `proceed` for around advice compiled by the AspectJ compiler. For around
-advice written using the traditional AspectJ language, the number of arguments passed to
-`proceed` must match the number of arguments passed to the around advice (not the number
-of arguments taken by the underlying join point), and the value passed to proceed in a
-given argument position supplants the original value at the join point for the entity the
-value was bound to (do not worry if this does not make sense right now).
-
-The approach taken by Spring is simpler and a better match to its proxy-based,
-execution-only semantics. You only need to be aware of this difference if you compile
-`@AspectJ` aspects written for Spring and use `proceed` with arguments with the AspectJ
-compiler and weaver. There is a way to write such aspects that is 100% compatible across
-both Spring AOP and AspectJ, and this is discussed in the
-xref:core/aop/ataspectj/advice.adoc#aop-ataspectj-advice-proceeding-with-the-call[following section on advice parameters].
-====
-
-The value returned by the around advice is the return value seen by the caller of the
-method. For example, a simple caching aspect could return a value from a cache if it has
-one or invoke `proceed()` (and return that value) if it does not. Note that `proceed`
-may be invoked once, many times, or not at all within the body of the around advice. All
-of these are legal.
-
-WARNING: If you declare the return type of your around advice method as `void`, `null`
-will always be returned to the caller, effectively ignoring the result of any invocation
-of `proceed()`. It is therefore recommended that an around advice method declare a return
-type of `Object`. The advice method should typically return the value returned from an
-invocation of `proceed()`, even if the underlying method has a `void` return type.
-However, the advice may optionally return a cached value, a wrapped value, or some other
-value depending on the use case.
-
-The following example shows how to use around advice:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.Around;
-	import org.aspectj.lang.ProceedingJoinPoint;
-
-	@Aspect
-	public class AroundExample {
-
-		@Around("execution(* com.xyz..service.*.*(..))")
-		public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
-			// start stopwatch
-			Object retVal = pjp.proceed();
-			// stop stopwatch
-			return retVal;
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.Around
-	import org.aspectj.lang.ProceedingJoinPoint
-
-	@Aspect
-	class AroundExample {
-
-		@Around("execution(* com.xyz..service.*.*(..))")
-		fun doBasicProfiling(pjp: ProceedingJoinPoint): Any? {
-			// start stopwatch
-			val retVal = pjp.proceed()
-			// stop stopwatch
-			return retVal
-		}
-	}
-----
-======
-
-[[aop-ataspectj-advice-params]]
-== Advice Parameters
-
-Spring offers fully typed advice, meaning that you declare the parameters you need in the
-advice signature (as we saw earlier for the returning and throwing examples) rather than
-work with `Object[]` arrays all the time. We see how to make argument and other contextual
-values available to the advice body later in this section. First, we take a look at how to
-write generic advice that can find out about the method the advice is currently advising.
-
-[[aop-ataspectj-advice-params-the-joinpoint]]
-=== Access to the Current `JoinPoint`
-
-Any advice method may declare, as its first parameter, a parameter of type
-`org.aspectj.lang.JoinPoint`. Note that around advice is required to declare a first
-parameter of type `ProceedingJoinPoint`, which is a subclass of `JoinPoint`.
-
-The `JoinPoint` interface provides a number of useful methods:
-
-* `getArgs()`: Returns the method arguments.
-* `getThis()`: Returns the proxy object.
-* `getTarget()`: Returns the target object.
-* `getSignature()`: Returns a description of the method that is being advised.
-* `toString()`: Prints a useful description of the method being advised.
-
-See the 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

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

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

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

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

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

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

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

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

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

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

@@ -1,586 +0,0 @@
-[[aop-pointcuts]]
-= Declaring a Pointcut
-
-Pointcuts determine join points of interest and thus enable us to control
-when advice runs. Spring AOP only supports method execution join points for Spring
-beans, so you can think of a pointcut as matching the execution of methods on Spring
-beans. A pointcut declaration has two parts: a signature comprising a name and any
-parameters and a pointcut expression that determines exactly which method
-executions we are interested in. In the @AspectJ annotation-style of AOP, a pointcut
-signature is provided by a regular method definition, and the pointcut expression is
-indicated by using the `@Pointcut` annotation (the method serving as the pointcut signature
-must have a `void` return type).
-
-An example may help make this distinction between a pointcut signature and a pointcut
-expression clear. The following example defines a pointcut named `anyOldTransfer` that
-matches the execution of any method named `transfer`:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Pointcut("execution(* transfer(..))") // the pointcut expression
-	private void anyOldTransfer() {} // the pointcut signature
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Pointcut("execution(* transfer(..))") // the pointcut expression
-	private fun anyOldTransfer() {} // the pointcut signature
-----
-======
-
-The pointcut expression that forms the value of the `@Pointcut` annotation is a regular
-AspectJ pointcut expression. For a full discussion of AspectJ's pointcut language, see
-the 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

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

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

@@ -1,79 +0,0 @@
-[[aop-introduction-defn]]
-= AOP Concepts
-
-Let us begin by defining some central AOP concepts and terminology. These terms are not
-Spring-specific. Unfortunately, AOP terminology is not particularly intuitive.
-However, it would be even more confusing if Spring used its own terminology.
-
-* Aspect: A modularization of a concern that cuts across multiple classes.
-  Transaction management is a good example of a crosscutting concern in enterprise Java
-  applications. In Spring AOP, aspects are implemented by using regular classes
-  (the xref:core/aop/schema.adoc[schema-based approach]) or regular classes annotated with the
-  `@Aspect` annotation (the xref:core/aop/ataspectj.adoc[@AspectJ style]).
-* Join point: A point during the execution of a program, such as the execution of a
-  method or the handling of an exception. In Spring AOP, a join point always
-  represents a method execution.
-* Advice: Action taken by an aspect at a particular join point. Different types of
-  advice include "around", "before", and "after" advice. (Advice types are discussed
-  later.) Many AOP frameworks, including Spring, model an advice as an interceptor and
-  maintain a chain of interceptors around the join point.
-* Pointcut: A predicate that matches join points. Advice is associated with a
-  pointcut expression and runs at any join point matched by the pointcut (for example,
-  the execution of a method with a certain name). The concept of join points as matched
-  by pointcut expressions is central to AOP, and Spring uses the AspectJ pointcut
-  expression language by default.
-* Introduction: Declaring additional methods or fields on behalf of a type. Spring
-  AOP lets you introduce new interfaces (and a corresponding implementation) to any
-  advised object. For example, you could use an introduction to make a bean implement an
-  `IsModified` interface, to simplify caching. (An introduction is known as an
-  inter-type declaration in the AspectJ community.)
-* Target object: An object being advised by one or more aspects. Also referred to as
-  the "advised object". Since Spring AOP is implemented by using runtime proxies, this
-  object is always a proxied object.
-* AOP proxy: An object created by the AOP framework in order to implement the aspect
-  contracts (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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +0,0 @@
-[[appendix]]
-= Appendix
-:page-section-summary-toc: 1
-
-
-
-

framework-docs/modules/ROOT/pages/core/appendix/application-startup-steps.adoc

@@ -1,57 +0,0 @@
-[[application-startup-steps]]
-= Application Startup Steps
-
-This part of the appendix lists the existing `StartupSteps` that the core container is instrumented with.
-
-WARNING: The name and detailed information about each startup step is not part of the public contract and
-is subject to change; this is considered as an implementation detail of the core container and will follow
-its behavior changes.
-
-.Application startup steps defined in the core container
-|===
-| Name| Description| Tags
-
-| `spring.beans.instantiate`
-| Instantiation of a bean and its dependencies.
-| `beanName` the name of the bean, `beanType` the type required at the injection point.
-
-| `spring.beans.smart-initialize`
-| Initialization of `SmartInitializingSingleton` beans.
-| `beanName` the name of the bean.
-
-| `spring.context.annotated-bean-reader.create`
-| Creation of the `AnnotatedBeanDefinitionReader`.
-|
-
-| `spring.context.base-packages.scan`
-| Scanning of base packages.
-| `packages` array of base packages for scanning.
-
-| `spring.context.beans.post-process`
-| Beans post-processing phase.
-|
-
-| `spring.context.bean-factory.post-process`
-| Invocation of the `BeanFactoryPostProcessor` beans.
-| `postProcessor` the current post-processor.
-
-| `spring.context.beandef-registry.post-process`
-| Invocation of the `BeanDefinitionRegistryPostProcessor` beans.
-| `postProcessor` the current post-processor.
-
-| `spring.context.component-classes.register`
-| Registration of component classes through `AnnotationConfigApplicationContext#register`.
-| `classes` array of given classes for registration.
-
-| `spring.context.config-classes.enhance`
-| Enhancement of configuration classes with CGLIB proxies.
-| `classCount` count of enhanced classes.
-
-| `spring.context.config-classes.parse`
-| Configuration classes parsing phase with the `ConfigurationClassPostProcessor`.
-| `classCount` count of processed classes.
-
-| `spring.context.refresh`
-| Application context refresh phase.
-|
-|===

framework-docs/modules/ROOT/pages/core/appendix/xsd-schemas.adoc

@@ -1,672 +0,0 @@
-[[xsd-schemas]]
-= XML Schemas
-
-This part of the appendix lists XML schemas related to the core container.
-
-
-
-[[xsd-schemas-util]]
-== The `util` Schema
-
-As the name implies, the `util` tags deal with common, utility configuration
-issues, such as configuring collections, referencing constants, and so forth.
-To use the tags in the `util` schema, you need to have the following preamble at the top
-of your Spring XML configuration file (the text in the snippet references the
-correct schema so that the tags in the `util` namespace are available to you):
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?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:util="http://www.springframework.org/schema/util"
-		xsi:schemaLocation="
-			http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
-			http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">
-
-			<!-- bean definitions here -->
-
-	</beans>
-----
-
-
-[[xsd-schemas-util-constant]]
-=== Using `<util:constant/>`
-
-Consider the following bean definition:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="..." class="...">
-		<property name="isolation">
-			<bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"
-					class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" />
-		</property>
-	</bean>
-----
-
-The preceding configuration uses a Spring `FactoryBean` implementation (the
-`FieldRetrievingFactoryBean`) to set the value of the `isolation` property on a bean
-to the value of the `java.sql.Connection.TRANSACTION_SERIALIZABLE` constant. This is
-all well and good, but it is verbose and (unnecessarily) exposes Spring's internal
-plumbing to the end user.
-
-The following XML Schema-based version is more concise, clearly expresses the
-developer's intent ("`inject this constant value`"), and it reads better:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="..." class="...">
-		<property name="isolation">
-			<util:constant static-field="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
-		</property>
-	</bean>
-----
-
-[[xsd-schemas-util-frfb]]
-==== Setting a Bean Property or Constructor Argument from a Field Value
-
-{api-spring-framework}/beans/factory/config/FieldRetrievingFactoryBean.html[`FieldRetrievingFactoryBean`]
-is a `FactoryBean` that retrieves a `static` or non-static field value. It is typically
-used for retrieving `public` `static` `final` constants, which may then be used to set a
-property value or constructor argument for another bean.
-
-The following example shows how a `static` field is exposed, by using the
-{api-spring-framework}/beans/factory/config/FieldRetrievingFactoryBean.html#setStaticField(java.lang.String)[`staticField`]
-property:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="myField"
-			class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
-		<property name="staticField" value="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
-	</bean>
-----
-
-There is also a convenience usage form where the `static` field is specified as the bean
-name, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"
-			class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"/>
-----
-
-This does mean that there is no longer any choice in what the bean `id` is (so any other
-bean that refers to it also has to use this longer name), but this form is very
-concise to define and very convenient to use as an inner bean since the `id` does not have
-to be specified for the bean reference, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="..." class="...">
-		<property name="isolation">
-			<bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"
-					class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" />
-		</property>
-	</bean>
-----
-
-You can also access a non-static (instance) field of another bean, as
-described in the API documentation for the
-{api-spring-framework}/beans/factory/config/FieldRetrievingFactoryBean.html[`FieldRetrievingFactoryBean`]
-class.
-
-Injecting enumeration values into beans as either property or constructor arguments is
-easy to do in Spring. You do not actually have to do anything or know anything about
-the Spring internals (or even about classes such as the `FieldRetrievingFactoryBean`).
-The following example enumeration shows how easy injecting an enum value is:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary",chomp="-packages"]
-----
-	package jakarta.persistence;
-
-	public enum PersistenceContextType {
-
-		TRANSACTION,
-		EXTENDED
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary",chomp="-packages"]
-----
-	package jakarta.persistence
-
-	enum class PersistenceContextType {
-
-		TRANSACTION,
-		EXTENDED
-	}
-----
-======
-
-Now consider the following setter of type `PersistenceContextType` and the corresponding bean definition:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary",chomp="-packages"]
-----
-	package example;
-
-	public class Client {
-
-		private PersistenceContextType persistenceContextType;
-
-		public void setPersistenceContextType(PersistenceContextType type) {
-			this.persistenceContextType = type;
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary",chomp="-packages"]
-----
-	package example
-
-	class Client {
-
-		lateinit var persistenceContextType: PersistenceContextType
-	}
-----
-======
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean class="example.Client">
-		<property name="persistenceContextType" value="TRANSACTION"/>
-	</bean>
-----
-
-
-[[xsd-schemas-util-property-path]]
-=== Using `<util:property-path/>`
-
-Consider the following example:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- target bean to be referenced by name -->
-	<bean id="testBean" class="org.springframework.beans.TestBean" scope="prototype">
-		<property name="age" value="10"/>
-		<property name="spouse">
-			<bean class="org.springframework.beans.TestBean">
-				<property name="age" value="11"/>
-			</bean>
-		</property>
-	</bean>
-
-	<!-- results in 10, which is the value of property 'age' of bean 'testBean' -->
-	<bean id="testBean.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>
-----
-
-The preceding configuration uses a Spring `FactoryBean` implementation (the
-`PropertyPathFactoryBean`) to create a bean (of type `int`) called `testBean.age` that
-has a value equal to the `age` property of the `testBean` bean.
-
-Now consider the following example, which adds a `<util:property-path/>` element:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- target bean to be referenced by name -->
-	<bean id="testBean" class="org.springframework.beans.TestBean" scope="prototype">
-		<property name="age" value="10"/>
-		<property name="spouse">
-			<bean class="org.springframework.beans.TestBean">
-				<property name="age" value="11"/>
-			</bean>
-		</property>
-	</bean>
-
-	<!-- results in 10, which is the value of property 'age' of bean 'testBean' -->
-	<util:property-path id="name" path="testBean.age"/>
-----
-
-The value of the `path` attribute of the `<property-path/>` element follows the form of
-`beanName.beanProperty`. In this case, it picks up the `age` property of the bean named
-`testBean`. The value of that `age` property is `10`.
-
-[[xsd-schemas-util-property-path-dependency]]
-==== Using `<util:property-path/>` to Set a Bean Property or Constructor Argument
-
-`PropertyPathFactoryBean` is a `FactoryBean` that evaluates a property path on a given
-target object. The target object can be specified directly or by a bean name. You can then use this
-value in another bean definition as a property value or constructor
-argument.
-
-The following example shows a path being used against another bean, by name:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- target bean to be referenced by name -->
-	<bean id="person" class="org.springframework.beans.TestBean" scope="prototype">
-		<property name="age" value="10"/>
-		<property name="spouse">
-			<bean class="org.springframework.beans.TestBean">
-				<property name="age" value="11"/>
-			</bean>
-		</property>
-	</bean>
-
-	<!-- results in 11, which is the value of property 'spouse.age' of bean 'person' -->
-	<bean id="theAge"
-			class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
-		<property name="targetBeanName" value="person"/>
-		<property name="propertyPath" value="spouse.age"/>
-	</bean>
-----
-
-In the following example, a path is evaluated against an inner bean:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- results in 12, which is the value of property 'age' of the inner bean -->
-	<bean id="theAge"
-			class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
-		<property name="targetObject">
-			<bean class="org.springframework.beans.TestBean">
-				<property name="age" value="12"/>
-			</bean>
-		</property>
-		<property name="propertyPath" value="age"/>
-	</bean>
-----
-
-There is also a shortcut form, where the bean name is the property path.
-The following example shows the shortcut form:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- results in 10, which is the value of property 'age' of bean 'person' -->
-	<bean id="person.age"
-			class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>
-----
-
-This form does mean that there is no choice in the name of the bean. Any reference to it
-also has to use the same `id`, which is the path. If used as an inner
-bean, there is no need to refer to it at all, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="..." class="...">
-		<property name="age">
-			<bean id="person.age"
-					class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>
-		</property>
-	</bean>
-----
-
-You can specifically set the result type in the actual definition. This is not necessary
-for most use cases, but it can sometimes be useful. See the javadoc for more info on
-this feature.
-
-
-[[xsd-schemas-util-properties]]
-=== Using `<util:properties/>`
-
-Consider the following example:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
-	<bean id="jdbcConfiguration" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
-		<property name="location" value="classpath:com/foo/jdbc-production.properties"/>
-	</bean>
-----
-
-The preceding configuration uses a Spring `FactoryBean` implementation (the
-`PropertiesFactoryBean`) to instantiate a `java.util.Properties` instance with values
-loaded from the supplied xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[`Resource`] location).
-
-The following example uses a `util:properties` element to make a more concise representation:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
-	<util:properties id="jdbcConfiguration" location="classpath:com/foo/jdbc-production.properties"/>
-----
-
-
-[[xsd-schemas-util-list]]
-=== Using `<util:list/>`
-
-Consider the following example:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- creates a java.util.List instance with values loaded from the supplied 'sourceList' -->
-	<bean id="emails" class="org.springframework.beans.factory.config.ListFactoryBean">
-		<property name="sourceList">
-			<list>
-				<value>pechorin@hero.org</value>
-				<value>raskolnikov@slums.org</value>
-				<value>stavrogin@gov.org</value>
-				<value>porfiry@gov.org</value>
-			</list>
-		</property>
-	</bean>
-----
-
-The preceding configuration uses a Spring `FactoryBean` implementation (the
-`ListFactoryBean`) to create a `java.util.List` instance and initialize it with values taken
-from the supplied `sourceList`.
-
-The following example uses a `<util:list/>` element to make a more concise representation:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- creates a java.util.List instance with the supplied values -->
-	<util:list id="emails">
-		<value>pechorin@hero.org</value>
-		<value>raskolnikov@slums.org</value>
-		<value>stavrogin@gov.org</value>
-		<value>porfiry@gov.org</value>
-	</util:list>
-----
-
-You can also explicitly control the exact type of `List` that is instantiated and
-populated by using the `list-class` attribute on the `<util:list/>` element. For
-example, if we really need a `java.util.LinkedList` to be instantiated, we could use the
-following configuration:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<util:list id="emails" list-class="java.util.LinkedList">
-		<value>jackshaftoe@vagabond.org</value>
-		<value>eliza@thinkingmanscrumpet.org</value>
-		<value>vanhoek@pirate.org</value>
-		<value>d'Arcachon@nemesis.org</value>
-	</util:list>
-----
-
-If no `list-class` attribute is supplied, the container chooses a `List` implementation.
-
-
-[[xsd-schemas-util-map]]
-=== Using `<util:map/>`
-
-Consider the following example:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- creates a java.util.Map instance with values loaded from the supplied 'sourceMap' -->
-	<bean id="emails" class="org.springframework.beans.factory.config.MapFactoryBean">
-		<property name="sourceMap">
-			<map>
-				<entry key="pechorin" value="pechorin@hero.org"/>
-				<entry key="raskolnikov" value="raskolnikov@slums.org"/>
-				<entry key="stavrogin" value="stavrogin@gov.org"/>
-				<entry key="porfiry" value="porfiry@gov.org"/>
-			</map>
-		</property>
-	</bean>
-----
-
-The preceding configuration uses a Spring `FactoryBean` implementation (the
-`MapFactoryBean`) to create a `java.util.Map` instance initialized with key-value pairs
-taken from the supplied `'sourceMap'`.
-
-The following example uses a `<util:map/>` element to make a more concise representation:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- creates a java.util.Map instance with the supplied key-value pairs -->
-	<util:map id="emails">
-		<entry key="pechorin" value="pechorin@hero.org"/>
-		<entry key="raskolnikov" value="raskolnikov@slums.org"/>
-		<entry key="stavrogin" value="stavrogin@gov.org"/>
-		<entry key="porfiry" value="porfiry@gov.org"/>
-	</util:map>
-----
-
-You can also explicitly control the exact type of `Map` that is instantiated and
-populated by using the `'map-class'` attribute on the `<util:map/>` element. For
-example, if we really need a `java.util.TreeMap` to be instantiated, we could use the
-following configuration:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<util:map id="emails" map-class="java.util.TreeMap">
-		<entry key="pechorin" value="pechorin@hero.org"/>
-		<entry key="raskolnikov" value="raskolnikov@slums.org"/>
-		<entry key="stavrogin" value="stavrogin@gov.org"/>
-		<entry key="porfiry" value="porfiry@gov.org"/>
-	</util:map>
-----
-
-If no `'map-class'` attribute is supplied, the container chooses a `Map` implementation.
-
-
-[[xsd-schemas-util-set]]
-=== Using `<util:set/>`
-
-Consider the following example:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- creates a java.util.Set instance with values loaded from the supplied 'sourceSet' -->
-	<bean id="emails" class="org.springframework.beans.factory.config.SetFactoryBean">
-		<property name="sourceSet">
-			<set>
-				<value>pechorin@hero.org</value>
-				<value>raskolnikov@slums.org</value>
-				<value>stavrogin@gov.org</value>
-				<value>porfiry@gov.org</value>
-			</set>
-		</property>
-	</bean>
-----
-
-The preceding configuration uses a Spring `FactoryBean` implementation (the
-`SetFactoryBean`) to create a `java.util.Set` instance initialized with values taken
-from the supplied `sourceSet`.
-
-The following example uses a `<util:set/>` element to make a more concise representation:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<!-- creates a java.util.Set instance with the supplied values -->
-	<util:set id="emails">
-		<value>pechorin@hero.org</value>
-		<value>raskolnikov@slums.org</value>
-		<value>stavrogin@gov.org</value>
-		<value>porfiry@gov.org</value>
-	</util:set>
-----
-
-You can also explicitly control the exact type of `Set` that is instantiated and
-populated by using the `set-class` attribute on the `<util:set/>` element. For
-example, if we really need a `java.util.TreeSet` to be instantiated, we could use the
-following configuration:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<util:set id="emails" set-class="java.util.TreeSet">
-		<value>pechorin@hero.org</value>
-		<value>raskolnikov@slums.org</value>
-		<value>stavrogin@gov.org</value>
-		<value>porfiry@gov.org</value>
-	</util:set>
-----
-
-If no `set-class` attribute is supplied, the container chooses a `Set` implementation.
-
-
-
-[[xsd-schemas-aop]]
-== The `aop` Schema
-
-The `aop` tags deal with configuring all things AOP in Spring, including Spring's
-own proxy-based AOP framework and Spring's integration with the AspectJ AOP framework.
-These tags are comprehensively covered in the chapter entitled xref:core/aop.adoc[Aspect Oriented Programming with Spring]
-.
-
-In the interest of completeness, to use the tags in the `aop` schema, you need to have
-the following preamble at the top of your Spring XML configuration file (the text in the
-snippet references the correct schema so that the tags in the `aop` namespace
-are available to you):
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?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: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">
-
-		<!-- bean definitions here -->
-
-	</beans>
-----
-
-
-
-[[xsd-schemas-context]]
-== The `context` Schema
-
-The `context` tags deal with `ApplicationContext` configuration that relates to plumbing
--- that is, not usually beans that are important to an end-user but rather beans that do
-a lot of the "`grunt`" work in Spring, such as `BeanfactoryPostProcessors`. The following
-snippet references the correct schema so that the elements in the `context` namespace are
-available to you:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?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">
-
-		<!-- bean definitions here -->
-
-	</beans>
-----
-
-
-[[xsd-schemas-context-pphc]]
-=== Using `<property-placeholder/>`
-
-This element activates the replacement of `${...}` placeholders, which are resolved against a
-specified properties file (as a xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Spring resource location]). This element
-is a convenience mechanism that sets up a xref:core/beans/factory-extension.adoc#beans-factory-placeholderconfigurer[`PropertySourcesPlaceholderConfigurer`]
- for you. If you need more control over the specific
-`PropertySourcesPlaceholderConfigurer` setup, you can explicitly define it as a bean yourself.
-
-[WARNING]
-=====
-Only one such element should be defined for a given application with the properties
-that it needs. Several property placeholders can be configured as long as they have distinct
-placeholder syntax (`${...}`).
-
-If you need to modularize the source of properties used for the replacement, you should
-not create multiple properties placeholders. Rather, each module should contribute a
-`PropertySource` to the `Environment`. Alternatively, you can create your own
-`PropertySourcesPlaceholderConfigurer` bean that gathers the properties to use.
-=====
-
-[[xsd-schemas-context-ac]]
-=== Using `<annotation-config/>`
-
-This element activates the Spring infrastructure to detect annotations in bean classes:
-
-* Spring's xref:core/beans/basics.adoc#beans-factory-metadata[`@Configuration`] model
-* xref:core/beans/annotation-config.adoc[`@Autowired`/`@Inject`], `@Value`, and `@Lookup`
-* JSR-250's `@Resource`, `@PostConstruct`, and `@PreDestroy` (if available)
-* JAX-WS's `@WebServiceRef` and EJB 3's `@EJB` (if available)
-* JPA's `@PersistenceContext` and `@PersistenceUnit` (if available)
-* Spring's xref:core/beans/context-introduction.adoc#context-functionality-events-annotation[`@EventListener`]
-
-Alternatively, you can choose to explicitly activate the individual `BeanPostProcessors`
-for those annotations.
-
-NOTE: This element does not activate processing of Spring's
-xref:data-access/transaction/declarative/annotations.adoc[`@Transactional`] annotation;
-you can use the <<data-access.adoc#tx-decl-explained, `<tx:annotation-driven/>`>>
-element for that purpose. Similarly, Spring's
-xref:integration/cache/annotations.adoc[caching annotations] need to be explicitly
-xref:integration/cache/annotations.adoc#cache-annotation-enable[enabled] as well.
-
-
-[[xsd-schemas-context-component-scan]]
-=== Using `<component-scan/>`
-
-This element is detailed in the section on xref:core/beans/annotation-config.adoc[annotation-based container configuration]
-.
-
-
-[[xsd-schemas-context-ltw]]
-=== Using `<load-time-weaver/>`
-
-This element is detailed in the section on xref:core/aop/using-aspectj.adoc#aop-aj-ltw[load-time weaving with AspectJ in the Spring Framework]
-.
-
-
-[[xsd-schemas-context-sc]]
-=== Using `<spring-configured/>`
-
-This element is detailed in the section on xref:core/aop/using-aspectj.adoc#aop-atconfigurable[using AspectJ to dependency inject domain objects with Spring]
-.
-
-
-[[xsd-schemas-context-mbe]]
-=== Using `<mbean-export/>`
-
-This element is detailed in the section on xref:integration/jmx/naming.adoc#jmx-context-mbeanexport[configuring annotation-based MBean export]
-.
-
-
-
-[[xsd-schemas-beans]]
-== The Beans Schema
-
-Last but not least, we have the elements in the `beans` schema. These elements
-have been in Spring since the very dawn of the framework. Examples of the various elements
-in the `beans` schema are not shown here because they are quite comprehensively covered
-in xref:core/beans/dependencies/factory-properties-detailed.adoc[dependencies and configuration in detail]
-(and, indeed, in that entire xref:web/webmvc-view/mvc-xslt.adoc#mvc-view-xslt-beandefs[chapter]).
-
-Note that you can add zero or more key-value pairs to `<bean/>` XML definitions.
-What, if anything, is done with this extra metadata is totally up to your own custom
-logic (and so is typically only of use if you write your own custom elements as described
-in the appendix entitled xref:core/appendix/xml-custom.adoc[XML Schema Authoring]).
-
-The following example shows the `<meta/>` element in the context of a surrounding `<bean/>`
-(note that, without any logic to interpret it, the metadata is effectively useless
-as it stands).
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?xml version="1.0" encoding="UTF-8"?>
-	<beans xmlns="http://www.springframework.org/schema/beans"
-		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		xsi:schemaLocation="
-			http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
-
-		<bean id="foo" class="x.y.Foo">
-			<meta key="cacheName" value="foo"/> <1>
-			<property name="name" value="Rick"/>
-		</bean>
-
-	</beans>
-----
-<1> This is the example `meta` element
-
-In the case of the preceding example, you could assume that there is some logic that consumes
-the bean definition and sets up some caching infrastructure that uses the supplied metadata.
-
-
-
-

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

@@ -1,9 +0,0 @@
-[[beans]]
-= The IoC Container
-:page-section-summary-toc: 1
-
-This chapter covers Spring's Inversion of Control (IoC) container.
-
-
-
-

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

@@ -1,81 +0,0 @@
-[[beans-annotation-config]]
-= Annotation-based Container Configuration
-
-.Are annotations better than XML for configuring Spring?
-****
-The introduction of annotation-based configuration raised the question of whether this
-approach is "`better`" than XML. The short answer is "`it depends.`" The long answer is
-that each approach has its pros and cons, and, usually, it is up to the developer to
-decide which strategy suits them better. Due to the way they are defined, annotations
-provide a lot of context in their declaration, leading to shorter and more concise
-configuration. However, XML excels at wiring up components without touching their source
-code or recompiling them. Some developers prefer having the wiring close to the source
-while others argue that annotated classes are no longer POJOs and, furthermore, that the
-configuration becomes decentralized and harder to control.
-
-No matter the choice, Spring can accommodate both styles and even mix them together.
-It is worth pointing out that through its xref:core/beans/java.adoc[JavaConfig] option, Spring lets
-annotations be used in a non-invasive way, without touching the target components'
-source code and that, in terms of tooling, all configuration styles are supported by
-https://spring.io/tools[Spring Tools] for Eclipse, Visual Studio Code, and Theia.
-****
-
-An alternative to XML setup is provided by annotation-based configuration, which relies
-on bytecode metadata for wiring up components instead of XML declarations. Instead of
-using XML to describe a bean wiring, the developer moves the configuration into the
-component class itself by using annotations on the relevant class, method, or field
-declaration. As mentioned in xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp-examples-aabpp[Example: The `AutowiredAnnotationBeanPostProcessor`], using a
-`BeanPostProcessor` in conjunction with annotations is a common means of extending the
-Spring IoC container. For example, the xref:core/beans/annotation-config/autowired.adoc[`@Autowired`]
-annotation provides the same capabilities as described in xref:core/beans/dependencies/factory-autowire.adoc[Autowiring Collaborators] but
-with more fine-grained control and wider applicability. In addition, Spring provides
-support for JSR-250 annotations, such as `@PostConstruct` and `@PreDestroy`, as well as
-support for JSR-330 (Dependency Injection for Java) annotations contained in the
-`jakarta.inject` package such as `@Inject` and `@Named`. Details about those annotations
-can be found in the xref:core/beans/standard-annotations.adoc[relevant section].
-
-[NOTE]
-====
-Annotation injection is performed before XML injection. Thus, the XML configuration
-overrides the annotations for properties wired through both approaches.
-====
-
-As always, you can register the post-processors as individual bean definitions, but they
-can also be implicitly registered by including the following tag in an XML-based Spring
-configuration (notice the inclusion of the `context` namespace):
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?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:annotation-config/>
-
-	</beans>
-----
-
-The `<context:annotation-config/>` element implicitly registers the following post-processors:
-
-* {api-spring-framework}/context/annotation/ConfigurationClassPostProcessor.html[`ConfigurationClassPostProcessor`]
-* {api-spring-framework}/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.html[`AutowiredAnnotationBeanPostProcessor`]
-* {api-spring-framework}/context/annotation/CommonAnnotationBeanPostProcessor.html[`CommonAnnotationBeanPostProcessor`]
-* {api-spring-framework}/orm/jpa/support/PersistenceAnnotationBeanPostProcessor.html[`PersistenceAnnotationBeanPostProcessor`]
-* {api-spring-framework}/context/event/EventListenerMethodProcessor.html[`EventListenerMethodProcessor`]
-
-[NOTE]
-====
-`<context:annotation-config/>` only looks for annotations on beans in the same
-application context in which it is defined. This means that, if you put
-`<context:annotation-config/>` in a `WebApplicationContext` for a `DispatcherServlet`,
-it only checks for `@Autowired` beans in your controllers, and not your services. See
-xref:web/webmvc/mvc-servlet.adoc[The DispatcherServlet] for more information.
-====
-
-
-

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

@@ -1,114 +0,0 @@
-[[beans-autowired-annotation-primary]]
-= Fine-tuning Annotation-based Autowiring with `@Primary`
-
-Because autowiring by type may lead to multiple candidates, it is often necessary to have
-more control over the selection process. One way to accomplish this is with Spring's
-`@Primary` annotation. `@Primary` indicates that a particular bean should be given
-preference when multiple beans are candidates to be autowired to a single-valued
-dependency. If exactly one primary bean exists among the candidates, it becomes the
-autowired value.
-
-Consider the following configuration that defines `firstMovieCatalog` as the
-primary `MovieCatalog`:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@Configuration
-	public class MovieConfiguration {
-
-		@Bean
-		@Primary
-		public MovieCatalog firstMovieCatalog() { ... }
-
-		@Bean
-		public MovieCatalog secondMovieCatalog() { ... }
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Configuration
-	class MovieConfiguration {
-
-		@Bean
-		@Primary
-		fun firstMovieCatalog(): MovieCatalog { ... }
-
-		@Bean
-		fun secondMovieCatalog(): MovieCatalog { ... }
-
-		// ...
-	}
-----
-======
-
-With the preceding configuration, the following `MovieRecommender` is autowired with the
-`firstMovieCatalog`:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		@Autowired
-		private MovieCatalog movieCatalog;
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-class MovieRecommender {
-
-	@Autowired
-	private lateinit var movieCatalog: MovieCatalog
-
-	// ...
-}
-----
-======
-
-The corresponding bean definitions follow:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?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:annotation-config/>
-
-		<bean class="example.SimpleMovieCatalog" primary="true">
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-		<bean class="example.SimpleMovieCatalog">
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-		<bean id="movieRecommender" class="example.MovieRecommender"/>
-
-	</beans>
-----
-
-
-

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

@@ -1,585 +0,0 @@
-[[beans-autowired-annotation-qualifiers]]
-= Fine-tuning Annotation-based Autowiring with Qualifiers
-
-`@Primary` is an effective way to use autowiring by type with several instances when one
-primary candidate can be determined. When you need more control over the selection process,
-you can use Spring's `@Qualifier` annotation. You can associate qualifier values
-with specific arguments, narrowing the set of type matches so that a specific bean is
-chosen for each argument. In the simplest case, this can be a plain descriptive value, as
-shown in the following example:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		@Autowired
-		@Qualifier("main")
-		private MovieCatalog movieCatalog;
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender {
-
-		@Autowired
-		@Qualifier("main")
-		private lateinit var movieCatalog: MovieCatalog
-
-		// ...
-	}
-----
-======
---
-
-You can also specify the `@Qualifier` annotation on individual constructor arguments or
-method parameters, as shown in the following example:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		private final MovieCatalog movieCatalog;
-
-		private final CustomerPreferenceDao customerPreferenceDao;
-
-		@Autowired
-		public void prepare(@Qualifier("main") MovieCatalog movieCatalog,
-				CustomerPreferenceDao customerPreferenceDao) {
-			this.movieCatalog = movieCatalog;
-			this.customerPreferenceDao = customerPreferenceDao;
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender {
-
-		private lateinit var movieCatalog: MovieCatalog
-
-		private lateinit var customerPreferenceDao: CustomerPreferenceDao
-
-		@Autowired
-		fun prepare(@Qualifier("main") movieCatalog: MovieCatalog,
-					customerPreferenceDao: CustomerPreferenceDao) {
-			this.movieCatalog = movieCatalog
-			this.customerPreferenceDao = customerPreferenceDao
-		}
-
-		// ...
-	}
-----
-======
---
-
-The following example shows corresponding bean definitions.
-
---
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?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:annotation-config/>
-
-		<bean class="example.SimpleMovieCatalog">
-			<qualifier value="main"/> <1>
-
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-		<bean class="example.SimpleMovieCatalog">
-			<qualifier value="action"/> <2>
-
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-		<bean id="movieRecommender" class="example.MovieRecommender"/>
-
-	</beans>
-----
-<1> The bean with the `main` qualifier value is wired with the constructor argument that
-is qualified with the same value.
-<2> The bean with the `action` qualifier value is wired with the constructor argument that
-is qualified with the same value.
---
-
-For a fallback match, the bean name is considered a default qualifier value. Thus, you
-can define the bean with an `id` of `main` instead of the nested qualifier element, leading
-to the same matching result. However, although you can use this convention to refer to
-specific beans by name, `@Autowired` is fundamentally about type-driven injection with
-optional semantic qualifiers. This means that qualifier values, even with the bean name
-fallback, always have narrowing semantics within the set of type matches. They do not
-semantically express a reference to a unique bean `id`. Good qualifier values are `main`
-or `EMEA` or `persistent`, expressing characteristics of a specific component that are
-independent from the bean `id`, which may be auto-generated in case of an anonymous bean
-definition such as the one in the preceding example.
-
-Qualifiers also apply to typed collections, as discussed earlier -- for example, to
-`Set<MovieCatalog>`. In this case, all matching beans, according to the declared
-qualifiers, are injected as a collection. This implies that qualifiers do not have to be
-unique. Rather, they constitute filtering criteria. For example, you can define
-multiple `MovieCatalog` beans with the same qualifier value "`action`", all of which are
-injected into a `Set<MovieCatalog>` annotated with `@Qualifier("action")`.
-
-[TIP]
-====
-Letting qualifier values select against target bean names, within the type-matching
-candidates, does not require a `@Qualifier` annotation at the injection point.
-If there is no other resolution indicator (such as a qualifier or a primary marker),
-for a non-unique dependency situation, Spring matches the injection point name
-(that is, the field name or parameter name) against the target bean names and chooses the
-same-named candidate, if any.
-====
-
-That said, if you intend to express annotation-driven injection by name, do not
-primarily use `@Autowired`, even if it is capable of selecting by bean name among
-type-matching candidates. Instead, use the JSR-250 `@Resource` annotation, which is
-semantically defined to identify a specific target component by its unique name, with
-the declared type being irrelevant for the matching process. `@Autowired` has rather
-different semantics: After selecting candidate beans by type, the specified `String`
-qualifier value is considered within those type-selected candidates only (for example,
-matching an `account` qualifier against beans marked with the same qualifier label).
-
-For beans that are themselves defined as a collection, `Map`, or array type, `@Resource`
-is a fine solution, referring to the specific collection or array bean by unique name.
-That said, as of 4.3, you can match collection, `Map`, and array types through Spring's
-`@Autowired` type matching algorithm as well, as long as the element type information
-is preserved in `@Bean` return type signatures or collection inheritance hierarchies.
-In this case, you can use qualifier values to select among same-typed collections,
-as outlined in the previous paragraph.
-
-As of 4.3, `@Autowired` also considers self references for injection (that is, references
-back to the bean that is currently injected). Note that self injection is a fallback.
-Regular dependencies on other components always have precedence. In that sense, self
-references do not participate in regular candidate selection and are therefore in
-particular never primary. On the contrary, they always end up as lowest precedence.
-In practice, you should use self references as a last resort only (for example, for
-calling other methods on the same instance through the bean's transactional proxy).
-Consider factoring out the affected methods to a separate delegate bean in such a scenario.
-Alternatively, you can use `@Resource`, which may obtain a proxy back to the current bean
-by its unique name.
-
-[NOTE]
-====
-Trying to inject the results from `@Bean` methods on the same configuration class is
-effectively a self-reference scenario as well. Either lazily resolve such references
-in the method signature where it is actually needed (as opposed to an autowired field
-in the configuration class) or declare the affected `@Bean` methods as `static`,
-decoupling them from the containing configuration class instance and its lifecycle.
-Otherwise, such beans are only considered in the fallback phase, with matching beans
-on other configuration classes selected as primary candidates instead (if available).
-====
-
-`@Autowired` applies to fields, constructors, and multi-argument methods, allowing for
-narrowing through qualifier annotations at the parameter level. In contrast, `@Resource`
-is supported only for fields and bean property setter methods with a single argument.
-As a consequence, you should stick with qualifiers if your injection target is a
-constructor or a multi-argument method.
-
-You can create your own custom qualifier annotations. To do so, define an annotation and
-provide the `@Qualifier` annotation within your definition, as the following example shows:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@Target({ElementType.FIELD, ElementType.PARAMETER})
-	@Retention(RetentionPolicy.RUNTIME)
-	@Qualifier
-	public @interface Genre {
-
-		String value();
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Target(AnnotationTarget.FIELD, AnnotationTarget.VALUE_PARAMETER)
-	@Retention(AnnotationRetention.RUNTIME)
-	@Qualifier
-	annotation class Genre(val value: String)
-----
-======
---
-
-Then you can provide the custom qualifier on autowired fields and parameters, as the
-following example shows:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		@Autowired
-		@Genre("Action")
-		private MovieCatalog actionCatalog;
-
-		private MovieCatalog comedyCatalog;
-
-		@Autowired
-		public void setComedyCatalog(@Genre("Comedy") MovieCatalog comedyCatalog) {
-			this.comedyCatalog = comedyCatalog;
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender {
-
-		@Autowired
-		@Genre("Action")
-		private lateinit var actionCatalog: MovieCatalog
-
-		private lateinit var comedyCatalog: MovieCatalog
-
-		@Autowired
-		fun setComedyCatalog(@Genre("Comedy") comedyCatalog: MovieCatalog) {
-			this.comedyCatalog = comedyCatalog
-		}
-
-		// ...
-	}
-----
-======
---
-
-Next, you can provide the information for the candidate bean definitions. You can add
-`<qualifier/>` tags as sub-elements of the `<bean/>` tag and then specify the `type` and
-`value` to match your custom qualifier annotations. The type is matched against the
-fully-qualified class name of the annotation. Alternately, as a convenience if no risk of
-conflicting names exists, you can use the short class name. The following example
-demonstrates both approaches:
-
---
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?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:annotation-config/>
-
-		<bean class="example.SimpleMovieCatalog">
-			<qualifier type="Genre" value="Action"/>
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-		<bean class="example.SimpleMovieCatalog">
-			<qualifier type="example.Genre" value="Comedy"/>
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-		<bean id="movieRecommender" class="example.MovieRecommender"/>
-
-	</beans>
-----
---
-
-In xref:core/beans/classpath-scanning.adoc[Classpath Scanning and Managed Components], you can see an annotation-based alternative to
-providing the qualifier metadata in XML. Specifically, see xref:core/beans/classpath-scanning.adoc#beans-scanning-qualifiers[Providing Qualifier Metadata with Annotations].
-
-In some cases, using an annotation without a value may suffice. This can be
-useful when the annotation serves a more generic purpose and can be applied across
-several different types of dependencies. For example, you may provide an offline
-catalog that can be searched when no Internet connection is available. First, define
-the simple annotation, as the following example shows:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@Target({ElementType.FIELD, ElementType.PARAMETER})
-	@Retention(RetentionPolicy.RUNTIME)
-	@Qualifier
-	public @interface Offline {
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Target(AnnotationTarget.FIELD, AnnotationTarget.VALUE_PARAMETER)
-	@Retention(AnnotationRetention.RUNTIME)
-	@Qualifier
-	annotation class Offline
-----
-======
---
-
-Then add the annotation to the field or property to be autowired, as shown in the
-following example:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		@Autowired
-		@Offline // <1>
-		private MovieCatalog offlineCatalog;
-
-		// ...
-	}
-----
-<1> This line adds the `@Offline` annotation.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-class MovieRecommender {
-
-	@Autowired
-	@Offline // <1>
-	private lateinit var offlineCatalog: MovieCatalog
-
-	// ...
-}
-----
-<1> This line adds the `@Offline` annotation.
-======
---
-
-Now the bean definition only needs a qualifier `type`, as shown in the following example:
-
---
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean class="example.SimpleMovieCatalog">
-		<qualifier type="Offline"/> <1>
-		<!-- inject any dependencies required by this bean -->
-	</bean>
-----
-<1> This element specifies the qualifier.
---
-
-
-You can also define custom qualifier annotations that accept named attributes in
-addition to or instead of the simple `value` attribute. If multiple attribute values are
-then specified on a field or parameter to be autowired, a bean definition must match
-all such attribute values to be considered an autowire candidate. As an example,
-consider the following annotation definition:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@Target({ElementType.FIELD, ElementType.PARAMETER})
-	@Retention(RetentionPolicy.RUNTIME)
-	@Qualifier
-	public @interface MovieQualifier {
-
-		String genre();
-
-		Format format();
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Target(AnnotationTarget.FIELD, AnnotationTarget.VALUE_PARAMETER)
-	@Retention(AnnotationRetention.RUNTIME)
-	@Qualifier
-	annotation class MovieQualifier(val genre: String, val format: Format)
-----
-======
---
-
-In this case `Format` is an enum, defined as follows:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public enum Format {
-		VHS, DVD, BLURAY
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	enum class Format {
-		VHS, DVD, BLURAY
-	}
-----
-======
---
-
-The fields to be autowired are annotated with the custom qualifier and include values
-for both attributes: `genre` and `format`, as the following example shows:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		@Autowired
-		@MovieQualifier(format=Format.VHS, genre="Action")
-		private MovieCatalog actionVhsCatalog;
-
-		@Autowired
-		@MovieQualifier(format=Format.VHS, genre="Comedy")
-		private MovieCatalog comedyVhsCatalog;
-
-		@Autowired
-		@MovieQualifier(format=Format.DVD, genre="Action")
-		private MovieCatalog actionDvdCatalog;
-
-		@Autowired
-		@MovieQualifier(format=Format.BLURAY, genre="Comedy")
-		private MovieCatalog comedyBluRayCatalog;
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender {
-
-		@Autowired
-		@MovieQualifier(format = Format.VHS, genre = "Action")
-		private lateinit var actionVhsCatalog: MovieCatalog
-
-		@Autowired
-		@MovieQualifier(format = Format.VHS, genre = "Comedy")
-		private lateinit var comedyVhsCatalog: MovieCatalog
-
-		@Autowired
-		@MovieQualifier(format = Format.DVD, genre = "Action")
-		private lateinit var actionDvdCatalog: MovieCatalog
-
-		@Autowired
-		@MovieQualifier(format = Format.BLURAY, genre = "Comedy")
-		private lateinit var comedyBluRayCatalog: MovieCatalog
-
-		// ...
-	}
-----
-======
---
-
-Finally, the bean definitions should contain matching qualifier values. This example
-also demonstrates that you can use bean meta attributes instead of the
-`<qualifier/>` elements. If available, the `<qualifier/>` element and its attributes take
-precedence, but the autowiring mechanism falls back on the values provided within the
-`<meta/>` tags if no such qualifier is present, as in the last two bean definitions in
-the following example:
-
---
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?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:annotation-config/>
-
-		<bean class="example.SimpleMovieCatalog">
-			<qualifier type="MovieQualifier">
-				<attribute key="format" value="VHS"/>
-				<attribute key="genre" value="Action"/>
-			</qualifier>
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-		<bean class="example.SimpleMovieCatalog">
-			<qualifier type="MovieQualifier">
-				<attribute key="format" value="VHS"/>
-				<attribute key="genre" value="Comedy"/>
-			</qualifier>
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-		<bean class="example.SimpleMovieCatalog">
-			<meta key="format" value="DVD"/>
-			<meta key="genre" value="Action"/>
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-		<bean class="example.SimpleMovieCatalog">
-			<meta key="format" value="BLURAY"/>
-			<meta key="genre" value="Comedy"/>
-			<!-- inject any dependencies required by this bean -->
-		</bean>
-
-	</beans>
-----
---
-
-
-

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

@@ -1,490 +0,0 @@
-[[beans-autowired-annotation]]
-= Using `@Autowired`
-
-[NOTE]
-====
-JSR 330's `@Inject` annotation can be used in place of Spring's `@Autowired` annotation in the
-examples included in this section. See xref:core/beans/standard-annotations.adoc[here] for more details.
-====
-
-You can apply the `@Autowired` annotation to constructors, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		private final CustomerPreferenceDao customerPreferenceDao;
-
-		@Autowired
-		public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
-			this.customerPreferenceDao = customerPreferenceDao;
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender @Autowired constructor(
-		private val customerPreferenceDao: CustomerPreferenceDao)
-----
-======
-
-[NOTE]
-====
-As of Spring Framework 4.3, an `@Autowired` annotation on such a constructor is no longer
-necessary if the target bean defines only one constructor to begin with. However, if
-several constructors are available and there is no primary/default constructor, at least
-one of the constructors must be annotated with `@Autowired` in order to instruct the
-container which one to use. See the discussion on
-xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-constructor-resolution[constructor resolution] for details.
-====
-
-You can also apply the `@Autowired` annotation to _traditional_ setter methods,
-as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class SimpleMovieLister {
-
-		private MovieFinder movieFinder;
-
-		@Autowired
-		public void setMovieFinder(MovieFinder movieFinder) {
-			this.movieFinder = movieFinder;
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class SimpleMovieLister {
-
-		@set:Autowired
-		lateinit var movieFinder: MovieFinder
-
-		// ...
-
-	}
-----
-======
-
-You can also apply the annotation to methods with arbitrary names and multiple
-arguments, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		private MovieCatalog movieCatalog;
-
-		private CustomerPreferenceDao customerPreferenceDao;
-
-		@Autowired
-		public void prepare(MovieCatalog movieCatalog,
-				CustomerPreferenceDao customerPreferenceDao) {
-			this.movieCatalog = movieCatalog;
-			this.customerPreferenceDao = customerPreferenceDao;
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender {
-
-		private lateinit var movieCatalog: MovieCatalog
-
-		private lateinit var customerPreferenceDao: CustomerPreferenceDao
-
-		@Autowired
-		fun prepare(movieCatalog: MovieCatalog,
-					customerPreferenceDao: CustomerPreferenceDao) {
-			this.movieCatalog = movieCatalog
-			this.customerPreferenceDao = customerPreferenceDao
-		}
-
-		// ...
-	}
-----
-======
-
-You can apply `@Autowired` to fields as well and even mix it with constructors, as the
-following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		private final CustomerPreferenceDao customerPreferenceDao;
-
-		@Autowired
-		private MovieCatalog movieCatalog;
-
-		@Autowired
-		public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
-			this.customerPreferenceDao = customerPreferenceDao;
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender @Autowired constructor(
-		private val customerPreferenceDao: CustomerPreferenceDao) {
-
-		@Autowired
-		private lateinit var movieCatalog: MovieCatalog
-
-		// ...
-	}
-----
-======
-
-[TIP]
-====
-Make sure that your target components (for example, `MovieCatalog` or `CustomerPreferenceDao`)
-are consistently declared by the type that you use for your `@Autowired`-annotated
-injection points. Otherwise, injection may fail due to a "no type match found" error at runtime.
-
-For XML-defined beans or component classes found via classpath scanning, the container
-usually knows the concrete type up front. However, for `@Bean` factory methods, you need
-to make sure that the declared return type is sufficiently expressive. For components
-that implement several interfaces or for components potentially referred to by their
-implementation type, consider declaring the most specific return type on your factory
-method (at least as specific as required by the injection points referring to your bean).
-====
-
-You can also instruct Spring to provide all beans of a particular type from the
-`ApplicationContext` by adding the `@Autowired` annotation to a field or method that
-expects an array of that type, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		@Autowired
-		private MovieCatalog[] movieCatalogs;
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender {
-
-		@Autowired
-		private lateinit var movieCatalogs: Array<MovieCatalog>
-
-		// ...
-	}
-----
-======
-
-The same applies for typed collections, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		private Set<MovieCatalog> movieCatalogs;
-
-		@Autowired
-		public void setMovieCatalogs(Set<MovieCatalog> movieCatalogs) {
-			this.movieCatalogs = movieCatalogs;
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender {
-
-		@Autowired
-		lateinit var movieCatalogs: Set<MovieCatalog>
-
-		// ...
-	}
-----
-======
-
-[[beans-factory-ordered]]
-[TIP]
-====
-Your target beans can implement the `org.springframework.core.Ordered` interface or use
-the `@Order` or standard `@Priority` annotation if you want items in the array or list
-to be sorted in a specific order. Otherwise, their order follows the registration
-order of the corresponding target bean definitions in the container.
-
-You can declare the `@Order` annotation at the target class level and on `@Bean` methods,
-potentially for individual bean definitions (in case of multiple definitions that
-use the same bean class). `@Order` values may influence priorities at injection points,
-but be aware that they do not influence singleton startup order, which is an
-orthogonal concern determined by dependency relationships and `@DependsOn` declarations.
-
-Note that the standard `jakarta.annotation.Priority` annotation is not available at the
-`@Bean` level, since it cannot be declared on methods. Its semantics can be modeled
-through `@Order` values in combination with `@Primary` on a single bean for each type.
-====
-
-Even typed `Map` instances can be autowired as long as the expected key type is `String`.
-The map values contain all beans of the expected type, and the keys contain the
-corresponding bean names, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		private Map<String, MovieCatalog> movieCatalogs;
-
-		@Autowired
-		public void setMovieCatalogs(Map<String, MovieCatalog> movieCatalogs) {
-			this.movieCatalogs = movieCatalogs;
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender {
-
-		@Autowired
-		lateinit var movieCatalogs: Map<String, MovieCatalog>
-
-		// ...
-	}
-----
-======
-
-By default, autowiring fails when no matching candidate beans are available for a given
-injection point. In the case of a declared array, collection, or map, at least one
-matching element is expected.
-
-The default behavior is to treat annotated methods and fields as indicating required
-dependencies. You can change this behavior as demonstrated in the following example,
-enabling the framework to skip a non-satisfiable injection point through marking it as
-non-required (i.e., by setting the `required` attribute in `@Autowired` to `false`):
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class SimpleMovieLister {
-
-		private MovieFinder movieFinder;
-
-		@Autowired(required = false)
-		public void setMovieFinder(MovieFinder movieFinder) {
-			this.movieFinder = movieFinder;
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class SimpleMovieLister {
-
-		@Autowired(required = false)
-		var movieFinder: MovieFinder? = null
-
-		// ...
-	}
-----
-======
-
-[NOTE]
-====
-A non-required method will not be called at all if its dependency (or one of its
-dependencies, in case of multiple arguments) is not available. A non-required field will
-not get populated at all in such cases, leaving its default value in place.
-
-In other words, setting the `required` attribute to `false` indicates that the
-corresponding property is _optional_ for autowiring purposes, and the property will be
-ignored if it cannot be autowired. This allows properties to be assigned default values
-that can be optionally overridden via dependency injection.
-====
-
-[[beans-autowired-annotation-constructor-resolution]]
-Injected constructor and factory method arguments are a special case since the `required`
-attribute in `@Autowired` has a somewhat different meaning due to Spring's constructor
-resolution algorithm that may potentially deal with multiple constructors. Constructor
-and factory method arguments are effectively required by default but with a few special
-rules in a single-constructor scenario, such as multi-element injection points (arrays,
-collections, maps) resolving to empty instances if no matching beans are available. This
-allows for a common implementation pattern where all dependencies can be declared in a
-unique multi-argument constructor — for example, declared as a single public constructor
-without an `@Autowired` annotation.
-
-[NOTE]
-====
-Only one constructor of any given bean class may declare `@Autowired` with the `required`
-attribute set to `true`, indicating _the_ constructor to autowire when used as a Spring
-bean. As a consequence, if the `required` attribute is left at its default value `true`,
-only a single constructor may be annotated with `@Autowired`. If multiple constructors
-declare the annotation, they will all have to declare `required=false` in order to be
-considered as candidates for autowiring (analogous to `autowire=constructor` in XML).
-The constructor with the greatest number of dependencies that can be satisfied by matching
-beans in the Spring container will be chosen. If none of the candidates can be satisfied,
-then a primary/default constructor (if present) will be used. Similarly, if a class
-declares multiple constructors but none of them is annotated with `@Autowired`, then a
-primary/default constructor (if present) will be used. If a class only declares a single
-constructor to begin with, it will always be used, even if not annotated. Note that an
-annotated constructor does not have to be public.
-====
-
-Alternatively, you can express the non-required nature of a particular dependency
-through Java 8's `java.util.Optional`, as the following example shows:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	public class SimpleMovieLister {
-
-		@Autowired
-		public void setMovieFinder(Optional<MovieFinder> movieFinder) {
-			...
-		}
-	}
-----
-
-As of Spring Framework 5.0, you can also use a `@Nullable` annotation (of any kind
-in any package -- for example, `javax.annotation.Nullable` from JSR-305) or just leverage
-Kotlin built-in null-safety support:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class SimpleMovieLister {
-
-		@Autowired
-		public void setMovieFinder(@Nullable MovieFinder movieFinder) {
-			...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class SimpleMovieLister {
-
-		@Autowired
-		var movieFinder: MovieFinder? = null
-
-		// ...
-	}
-----
-======
-
-You can also use `@Autowired` for interfaces that are well-known resolvable
-dependencies: `BeanFactory`, `ApplicationContext`, `Environment`, `ResourceLoader`,
-`ApplicationEventPublisher`, and `MessageSource`. These interfaces and their extended
-interfaces, such as `ConfigurableApplicationContext` or `ResourcePatternResolver`, are
-automatically resolved, with no special setup necessary. The following example autowires
-an `ApplicationContext` object:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		@Autowired
-		private ApplicationContext context;
-
-		public MovieRecommender() {
-		}
-
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-class MovieRecommender {
-
-	@Autowired
-	lateinit var context: ApplicationContext
-
-	// ...
-}
-----
-======
-
-[NOTE]
-====
-The `@Autowired`, `@Inject`, `@Value`, and `@Resource` annotations are handled by Spring
-`BeanPostProcessor` implementations. This means that you cannot apply these annotations
-within your own `BeanPostProcessor` or `BeanFactoryPostProcessor` types (if any).
-These types must be 'wired up' explicitly by using XML or a Spring `@Bean` method.
-====
-
-
-

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

@@ -1,33 +0,0 @@
-[[beans-custom-autowire-configurer]]
-= Using `CustomAutowireConfigurer`
-
-{api-spring-framework}/beans/factory/annotation/CustomAutowireConfigurer.html[`CustomAutowireConfigurer`]
-is a `BeanFactoryPostProcessor` that lets you register your own custom qualifier
-annotation types, even if they are not annotated with Spring's `@Qualifier` annotation.
-The following example shows how to use `CustomAutowireConfigurer`:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="customAutowireConfigurer"
-			class="org.springframework.beans.factory.annotation.CustomAutowireConfigurer">
-		<property name="customQualifierTypes">
-			<set>
-				<value>example.CustomQualifier</value>
-			</set>
-		</property>
-	</bean>
-----
-
-The `AutowireCandidateResolver` determines autowire candidates by:
-
-* The `autowire-candidate` value of each bean definition
-* Any `default-autowire-candidates` patterns available on the `<beans/>` element
-* The presence of `@Qualifier` annotations and any custom annotations registered
-with the `CustomAutowireConfigurer`
-
-When multiple beans qualify as autowire candidates, the determination of a "`primary`" is
-as follows: If exactly one bean definition among the candidates has a `primary`
-attribute set to `true`, it is selected.
-
-
-

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

@@ -1,101 +0,0 @@
-[[beans-generics-as-qualifiers]]
-= Using Generics as Autowiring Qualifiers
-
-In addition to the `@Qualifier` annotation, you can use Java generic types
-as an implicit form of qualification. For example, suppose you have the following
-configuration:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@Configuration
-	public class MyConfiguration {
-
-		@Bean
-		public StringStore stringStore() {
-			return new StringStore();
-		}
-
-		@Bean
-		public IntegerStore integerStore() {
-			return new IntegerStore();
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Configuration
-	class MyConfiguration {
-
-		@Bean
-		fun stringStore() = StringStore()
-
-		@Bean
-		fun integerStore() = IntegerStore()
-	}
-----
-======
-
-Assuming that the preceding beans implement a generic interface, (that is, `Store<String>` and
-`Store<Integer>`), you can `@Autowire` the `Store` interface and the generic is
-used as a qualifier, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@Autowired
-	private Store<String> s1; // <String> qualifier, injects the stringStore bean
-
-	@Autowired
-	private Store<Integer> s2; // <Integer> qualifier, injects the integerStore bean
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Autowired
-	private lateinit var s1: Store<String> // <String> qualifier, injects the stringStore bean
-
-	@Autowired
-	private lateinit var s2: Store<Integer> // <Integer> qualifier, injects the integerStore bean
-----
-======
-
-Generic qualifiers also apply when autowiring lists, `Map` instances and arrays. The
-following example autowires a generic `List`:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	// Inject all Store beans as long as they have an <Integer> generic
-	// Store<String> beans will not appear in this list
-	@Autowired
-	private List<Store<Integer>> s;
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	// Inject all Store beans as long as they have an <Integer> generic
-	// Store<String> beans will not appear in this list
-	@Autowired
-	private lateinit var s: List<Store<Integer>>
-----
-======
-
-
-

framework-docs/modules/ROOT/pages/core/beans/annotation-config/postconstruct-and-predestroy-annotations.adoc

@@ -1,70 +0,0 @@
-[[beans-postconstruct-and-predestroy-annotations]]
-= Using `@PostConstruct` and `@PreDestroy`
-
-The `CommonAnnotationBeanPostProcessor` not only recognizes the `@Resource` annotation
-but also the JSR-250 lifecycle annotations: `jakarta.annotation.PostConstruct` and
-`jakarta.annotation.PreDestroy`. Introduced in Spring 2.5, the support for these
-annotations offers an alternative to the lifecycle callback mechanism described in
-xref:core/beans/factory-nature.adoc#beans-factory-lifecycle-initializingbean[initialization callbacks] and
-xref:core/beans/factory-nature.adoc#beans-factory-lifecycle-disposablebean[destruction callbacks]. Provided that the
-`CommonAnnotationBeanPostProcessor` is registered within the Spring `ApplicationContext`,
-a method carrying one of these annotations is invoked at the same point in the lifecycle
-as the corresponding Spring lifecycle interface method or explicitly declared callback
-method. In the following example, the cache is pre-populated upon initialization and
-cleared upon destruction:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class CachingMovieLister {
-
-		@PostConstruct
-		public void populateMovieCache() {
-			// populates the movie cache upon initialization...
-		}
-
-		@PreDestroy
-		public void clearMovieCache() {
-			// clears the movie cache upon destruction...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class CachingMovieLister {
-
-		@PostConstruct
-		fun populateMovieCache() {
-			// populates the movie cache upon initialization...
-		}
-
-		@PreDestroy
-		fun clearMovieCache() {
-			// clears the movie cache upon destruction...
-		}
-	}
-----
-======
-
-For details about the effects of combining various lifecycle mechanisms, see
-xref:core/beans/factory-nature.adoc#beans-factory-lifecycle-combined-effects[Combining Lifecycle Mechanisms].
-
-[NOTE]
-====
-Like `@Resource`, the `@PostConstruct` and `@PreDestroy` annotation types were a part
-of the standard Java libraries from JDK 6 to 8. However, the entire `javax.annotation`
-package got separated from the core Java modules in JDK 9 and eventually removed in
-JDK 11. As of Jakarta EE 9, the package lives in `jakarta.annotation` now. If needed,
-the `jakarta.annotation-api` artifact needs to be obtained via Maven Central now,
-simply to be added to the application's classpath like any other library.
-====
-
-
-
-

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

@@ -1,145 +0,0 @@
-[[beans-resource-annotation]]
-= Injection with `@Resource`
-
-Spring also supports injection by using the JSR-250 `@Resource` annotation
-(`jakarta.annotation.Resource`) on fields or bean property setter methods.
-This is a common pattern in Jakarta EE: for example, in JSF-managed beans and JAX-WS
-endpoints. Spring supports this pattern for Spring-managed objects as well.
-
-`@Resource` takes a name attribute. By default, Spring interprets that value as
-the bean name to be injected. In other words, it follows by-name semantics,
-as demonstrated in the following example:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class SimpleMovieLister {
-
-		private MovieFinder movieFinder;
-
-		@Resource(name="myMovieFinder") // <1>
-		public void setMovieFinder(MovieFinder movieFinder) {
-			this.movieFinder = movieFinder;
-		}
-	}
-----
-<1> This line injects a `@Resource`.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-class SimpleMovieLister {
-
-	@Resource(name="myMovieFinder") // <1>
-	private lateinit var movieFinder:MovieFinder
-}
-----
-<1> This line injects a `@Resource`.
-======
---
-
-
-If no name is explicitly specified, the default name is derived from the field name or
-setter method. In case of a field, it takes the field name. In case of a setter method,
-it takes the bean property name. The following example is going to have the bean
-named `movieFinder` injected into its setter method:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class SimpleMovieLister {
-
-		private MovieFinder movieFinder;
-
-		@Resource
-		public void setMovieFinder(MovieFinder movieFinder) {
-			this.movieFinder = movieFinder;
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class SimpleMovieLister {
-
-		@set:Resource
-		private lateinit var movieFinder: MovieFinder
-
-	}
-----
-======
---
-
-NOTE: The name provided with the annotation is resolved as a bean name by the
-`ApplicationContext` of which the `CommonAnnotationBeanPostProcessor` is aware.
-The names can be resolved through JNDI if you configure Spring's
-{api-spring-framework}/jndi/support/SimpleJndiBeanFactory.html[`SimpleJndiBeanFactory`]
-explicitly. However, we recommend that you rely on the default behavior and
-use Spring's JNDI lookup capabilities to preserve the level of indirection.
-
-In the exclusive case of `@Resource` usage with no explicit name specified, and similar
-to `@Autowired`, `@Resource` finds a primary type match instead of a specific named bean
-and resolves well known resolvable dependencies: the `BeanFactory`,
-`ApplicationContext`, `ResourceLoader`, `ApplicationEventPublisher`, and `MessageSource`
-interfaces.
-
-Thus, in the following example, the `customerPreferenceDao` field first looks for a bean
-named "customerPreferenceDao" and then falls back to a primary type match for the type
-`CustomerPreferenceDao`:
-
---
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class MovieRecommender {
-
-		@Resource
-		private CustomerPreferenceDao customerPreferenceDao;
-
-		@Resource
-		private ApplicationContext context; // <1>
-
-		public MovieRecommender() {
-		}
-
-		// ...
-	}
-----
-<1> The `context` field is injected based on the known resolvable dependency type:
-`ApplicationContext`.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class MovieRecommender {
-
-		@Resource
-		private lateinit var customerPreferenceDao: CustomerPreferenceDao
-
-
-		@Resource
-		private lateinit var context: ApplicationContext // <1>
-
-		// ...
-	}
-----
-<1> The `context` field is injected based on the known resolvable dependency type:
-`ApplicationContext`.
-======
---
-

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

@@ -1,242 +0,0 @@
-[[beans-value-annotations]]
-= Using `@Value`
-
-`@Value` is typically used to inject externalized properties:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-    @Component
-    public class MovieRecommender {
-
-        private final String catalog;
-
-        public MovieRecommender(@Value("${catalog.name}") String catalog) {
-            this.catalog = catalog;
-        }
-    }
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Component
-	class MovieRecommender(@Value("\${catalog.name}") private val catalog: String)
-----
-======
-
-With the following configuration:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-    @Configuration
-    @PropertySource("classpath:application.properties")
-    public class AppConfig { }
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Configuration
-	@PropertySource("classpath:application.properties")
-	class AppConfig
-----
-======
-
-And the following `application.properties` file:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-    catalog.name=MovieCatalog
-----
-
-In that case, the `catalog` parameter and field will be equal to the `MovieCatalog` value.
-
-A default lenient embedded value resolver is provided by Spring. It will try to resolve the
-property value and if it cannot be resolved, the property name (for example `${catalog.name}`)
-will be injected as the value. If you want to maintain strict control over nonexistent
-values, you should declare a `PropertySourcesPlaceholderConfigurer` bean, as the following
-example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@Configuration
-	public class AppConfig {
-
-		@Bean
-		public static PropertySourcesPlaceholderConfigurer propertyPlaceholderConfigurer() {
-			return new PropertySourcesPlaceholderConfigurer();
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Configuration
-	class AppConfig {
-
-		@Bean
-		fun propertyPlaceholderConfigurer() = PropertySourcesPlaceholderConfigurer()
-	}
-----
-======
-
-NOTE: When configuring a `PropertySourcesPlaceholderConfigurer` using JavaConfig, the
-`@Bean` method must be `static`.
-
-Using the above configuration ensures Spring initialization failure if any `${}`
-placeholder could not be resolved. It is also possible to use methods like
-`setPlaceholderPrefix`, `setPlaceholderSuffix`, or `setValueSeparator` to customize
-placeholders.
-
-NOTE: Spring Boot configures by default a `PropertySourcesPlaceholderConfigurer` bean that
-will get properties from `application.properties` and `application.yml` files.
-
-Built-in converter support provided by Spring allows simple type conversion (to `Integer`
-or `int` for example) to be automatically handled. Multiple comma-separated values can be
-automatically converted to `String` array without extra effort.
-
-It is possible to provide a default value as following:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-    @Component
-    public class MovieRecommender {
-
-        private final String catalog;
-
-        public MovieRecommender(@Value("${catalog.name:defaultCatalog}") String catalog) {
-            this.catalog = catalog;
-        }
-    }
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Component
-	class MovieRecommender(@Value("\${catalog.name:defaultCatalog}") private val catalog: String)
-----
-======
-
-A Spring `BeanPostProcessor` uses a `ConversionService` behind the scenes to handle the
-process for converting the `String` value in `@Value` to the target type. If you want to
-provide conversion support for your own custom type, you can provide your own
-`ConversionService` bean instance as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-    @Configuration
-    public class AppConfig {
-
-        @Bean
-        public ConversionService conversionService() {
-            DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
-            conversionService.addConverter(new MyCustomConverter());
-            return conversionService;
-        }
-    }
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Configuration
-	class AppConfig {
-
-		@Bean
-		fun conversionService(): ConversionService {
-			return DefaultFormattingConversionService().apply {
-				addConverter(MyCustomConverter())
-			}
-		}
-	}
-----
-======
-
-When `@Value` contains a xref:core/expressions.adoc[`SpEL` expression] the value will be dynamically
-computed at runtime as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-    @Component
-    public class MovieRecommender {
-
-        private final String catalog;
-
-        public MovieRecommender(@Value("#{systemProperties['user.catalog'] + 'Catalog' }") String catalog) {
-            this.catalog = catalog;
-        }
-    }
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Component
-	class MovieRecommender(
-		@Value("#{systemProperties['user.catalog'] + 'Catalog' }") private val catalog: String)
-----
-======
-
-SpEL also enables the use of more complex data structures:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-    @Component
-    public class MovieRecommender {
-
-        private final Map<String, Integer> countOfMoviesPerCatalog;
-
-        public MovieRecommender(
-                @Value("#{{'Thriller': 100, 'Comedy': 300}}") Map<String, Integer> countOfMoviesPerCatalog) {
-            this.countOfMoviesPerCatalog = countOfMoviesPerCatalog;
-        }
-    }
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Component
-	class MovieRecommender(
-		@Value("#{{'Thriller': 100, 'Comedy': 300}}") private val countOfMoviesPerCatalog: Map<String, Int>)
-----
-======
-
-

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

@@ -1,423 +0,0 @@
-[[beans-basics]]
-= Container Overview
-
-The `org.springframework.context.ApplicationContext` interface represents the Spring IoC
-container and is responsible for instantiating, configuring, and assembling the
-beans. The container gets its instructions on what objects to
-instantiate, configure, and assemble by reading configuration metadata. The
-configuration metadata is represented in XML, Java annotations, or Java code. It lets
-you express the objects that compose your application and the rich interdependencies
-between those objects.
-
-Several implementations of the `ApplicationContext` interface are supplied
-with Spring. In stand-alone applications, it is common to create an
-instance of
-{api-spring-framework}/context/support/ClassPathXmlApplicationContext.html[`ClassPathXmlApplicationContext`]
-or {api-spring-framework}/context/support/FileSystemXmlApplicationContext.html[`FileSystemXmlApplicationContext`].
-While XML has been the traditional format for defining configuration metadata, you can
-instruct the container to use Java annotations or code as the metadata format by
-providing a small amount of XML configuration to declaratively enable support for these
-additional metadata formats.
-
-In most application scenarios, explicit user code is not required to instantiate one or
-more instances of a Spring IoC container. For example, in a web application scenario, a
-simple eight (or so) lines of boilerplate web descriptor XML in the `web.xml` file
-of the application typically suffices (see
-xref:core/beans/context-introduction.adoc#context-create[Convenient ApplicationContext Instantiation for Web Applications]).
-If you use the https://spring.io/tools[Spring Tools for Eclipse] (an Eclipse-powered
-development environment), you can easily create this boilerplate configuration with a
-few mouse clicks or keystrokes.
-
-The following diagram shows a high-level view of how Spring works. Your application classes
-are combined with configuration metadata so that, after the `ApplicationContext` is
-created and initialized, you have a fully configured and executable system or
-application.
-
-.The Spring IoC container
-image::container-magic.png[]
-
-
-
-[[beans-factory-metadata]]
-== Configuration Metadata
-
-As the preceding diagram shows, the Spring IoC container consumes a form of
-configuration metadata. This configuration metadata represents how you, as an
-application developer, tell the Spring container to instantiate, configure, and assemble
-the objects in your application.
-
-Configuration metadata is traditionally supplied in a simple and intuitive XML format,
-which is what most of this chapter uses to convey key concepts and features of the
-Spring IoC container.
-
-NOTE: XML-based metadata is not the only allowed form of configuration metadata.
-The Spring IoC container itself is totally decoupled from the format in which this
-configuration metadata is actually written. These days, many developers choose
-xref:core/beans/java.adoc[Java-based configuration] for their Spring applications.
-
-For information about using other forms of metadata with the Spring container, see:
-
-* xref:core/beans/annotation-config.adoc[Annotation-based configuration]: define beans using
-  annotation-based configuration metadata.
-* xref:core/beans/java.adoc[Java-based configuration]: define beans external to your application
-  classes by using Java rather than XML files. To use these features, see the
-  {api-spring-framework}/context/annotation/Configuration.html[`@Configuration`],
-  {api-spring-framework}/context/annotation/Bean.html[`@Bean`],
-  {api-spring-framework}/context/annotation/Import.html[`@Import`],
-  and {api-spring-framework}/context/annotation/DependsOn.html[`@DependsOn`] annotations.
-
-Spring configuration consists of at least one and typically more than one bean
-definition that the container must manage. XML-based configuration metadata configures these
-beans as `<bean/>` elements inside a top-level `<beans/>` element. Java
-configuration typically uses `@Bean`-annotated methods within a `@Configuration` class.
-
-These bean definitions correspond to the actual objects that make up your application.
-Typically, you define service layer objects, persistence layer objects such as
-repositories or data access objects (DAOs), presentation objects such as Web controllers,
-infrastructure objects such as a JPA `EntityManagerFactory`, JMS queues, and so forth.
-Typically, one does not configure fine-grained domain objects in the container, because
-it is usually the responsibility of repositories and business logic to create and load
-domain objects.
-
-The following example shows the basic structure of XML-based configuration metadata:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?xml version="1.0" encoding="UTF-8"?>
-	<beans xmlns="http://www.springframework.org/schema/beans"
-		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		xsi:schemaLocation="http://www.springframework.org/schema/beans
-			https://www.springframework.org/schema/beans/spring-beans.xsd">
-
-		<bean id="..." class="..."> <1> <2>
-			<!-- collaborators and configuration for this bean go here -->
-		</bean>
-
-		<bean id="..." class="...">
-			<!-- collaborators and configuration for this bean go here -->
-		</bean>
-
-		<!-- more bean definitions go here -->
-
-	</beans>
-----
-
-<1> The `id` attribute is a string that identifies the individual bean definition.
-<2> The `class` attribute defines the type of the bean and uses the fully qualified
-class name.
-
-The value of the `id` attribute can be used to refer to collaborating objects. The XML
-for referring to collaborating objects is not shown in this example. See
-xref:core/beans/dependencies.adoc[Dependencies] for more information.
-
-
-
-[[beans-factory-instantiation]]
-== Instantiating a Container
-
-The location path or paths
-supplied to an `ApplicationContext` constructor are resource strings that let
-the container load configuration metadata from a variety of external resources, such
-as the local file system, the Java `CLASSPATH`, and so on.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-    val context = ClassPathXmlApplicationContext("services.xml", "daos.xml")
-----
-======
-
-[NOTE]
-====
-After you learn about Spring's IoC container, you may want to know more about Spring's
-`Resource` abstraction (as described in
-xref:core/resources.adoc[Resources])
-which provides a convenient mechanism for reading an InputStream from locations defined
-in a URI syntax. In particular, `Resource` paths are used to construct applications contexts,
-as described in xref:core/resources.adoc#resources-app-ctx[Application Contexts and Resource Paths].
-====
-
-The following example shows the service layer objects `(services.xml)` configuration file:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?xml version="1.0" encoding="UTF-8"?>
-	<beans xmlns="http://www.springframework.org/schema/beans"
-		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		xsi:schemaLocation="http://www.springframework.org/schema/beans
-			https://www.springframework.org/schema/beans/spring-beans.xsd">
-
-		<!-- services -->
-
-		<bean id="petStore" class="org.springframework.samples.jpetstore.services.PetStoreServiceImpl">
-			<property name="accountDao" ref="accountDao"/>
-			<property name="itemDao" ref="itemDao"/>
-			<!-- additional collaborators and configuration for this bean go here -->
-		</bean>
-
-		<!-- more bean definitions for services go here -->
-
-	</beans>
-----
-
-The following example shows the data access objects `daos.xml` file:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<?xml version="1.0" encoding="UTF-8"?>
-	<beans xmlns="http://www.springframework.org/schema/beans"
-		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		xsi:schemaLocation="http://www.springframework.org/schema/beans
-			https://www.springframework.org/schema/beans/spring-beans.xsd">
-
-		<bean id="accountDao"
-			class="org.springframework.samples.jpetstore.dao.jpa.JpaAccountDao">
-			<!-- additional collaborators and configuration for this bean go here -->
-		</bean>
-
-		<bean id="itemDao" class="org.springframework.samples.jpetstore.dao.jpa.JpaItemDao">
-			<!-- additional collaborators and configuration for this bean go here -->
-		</bean>
-
-		<!-- more bean definitions for data access objects go here -->
-
-	</beans>
-----
-
-In the preceding example, the service layer consists of the `PetStoreServiceImpl` class
-and two data access objects of the types `JpaAccountDao` and `JpaItemDao` (based
-on the JPA Object-Relational Mapping standard). The `property name` element refers to the
-name of the JavaBean property, and the `ref` element refers to the name of another bean
-definition. This linkage between `id` and `ref` elements expresses the dependency between
-collaborating objects. For details of configuring an object's dependencies, see
-xref:core/beans/dependencies.adoc[Dependencies].
-
-
-[[beans-factory-xml-import]]
-=== Composing XML-based Configuration Metadata
-
-It can be useful to have bean definitions span multiple XML files. Often, each individual
-XML configuration file represents a logical layer or module in your architecture.
-
-You can use the application context constructor to load bean definitions from all these
-XML fragments. This constructor takes multiple `Resource` locations, as was shown in the
-xref:core/beans/basics.adoc#beans-factory-instantiation[previous section]. Alternatively,
-use one or more occurrences of the `<import/>` element to load bean definitions from
-another file or files. The following example shows how to do so:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<beans>
-		<import resource="services.xml"/>
-		<import resource="resources/messageSource.xml"/>
-		<import resource="/resources/themeSource.xml"/>
-
-		<bean id="bean1" class="..."/>
-		<bean id="bean2" class="..."/>
-	</beans>
-----
-
-In the preceding example, external bean definitions are loaded from three files:
-`services.xml`, `messageSource.xml`, and `themeSource.xml`. All location paths are
-relative to the definition file doing the importing, so `services.xml` must be in the
-same directory or classpath location as the file doing the importing, while
-`messageSource.xml` and `themeSource.xml` must be in a `resources` location below the
-location of the importing file. As you can see, a leading slash is ignored. However, given
-that these paths are relative, it is better form not to use the slash at all. The
-contents of the files being imported, including the top level `<beans/>` element, must
-be valid XML bean definitions, according to the Spring Schema.
-
-[NOTE]
-====
-It is possible, but not recommended, to reference files in parent directories using a
-relative "../" path. Doing so creates a dependency on a file that is outside the current
-application. In particular, this reference is not recommended for `classpath:` URLs (for
-example, `classpath:../services.xml`), where the runtime resolution process chooses the
-"`nearest`" classpath root and then looks into its parent directory. Classpath
-configuration changes may lead to the choice of a different, incorrect directory.
-
-You can always use fully qualified resource locations instead of relative paths: for
-example, `file:C:/config/services.xml` or `classpath:/config/services.xml`. However, be
-aware that you are coupling your application's configuration to specific absolute
-locations. It is generally preferable to keep an indirection for such absolute
-locations -- for example, through "${...}" placeholders that are resolved against JVM
-system properties at runtime.
-====
-
-The namespace itself provides the import directive feature. Further
-configuration features beyond plain bean definitions are available in a selection
-of XML namespaces provided by Spring -- for example, the `context` and `util` namespaces.
-
-
-[[groovy-bean-definition-dsl]]
-=== The Groovy Bean Definition DSL
-
-As a further example for externalized configuration metadata, bean definitions can also
-be expressed in Spring's Groovy Bean Definition DSL, as known from the Grails framework.
-Typically, such configuration live in a ".groovy" file with the structure shown in the
-following example:
-
-[source,groovy,indent=0,subs="verbatim,quotes"]
-----
-	beans {
-		dataSource(BasicDataSource) {
-			driverClassName = "org.hsqldb.jdbcDriver"
-			url = "jdbc:hsqldb:mem:grailsDB"
-			username = "sa"
-			password = ""
-			settings = [mynew:"setting"]
-		}
-		sessionFactory(SessionFactory) {
-			dataSource = dataSource
-		}
-		myService(MyService) {
-			nestedBean = { AnotherBean bean ->
-				dataSource = dataSource
-			}
-		}
-	}
-----
-
-This configuration style is largely equivalent to XML bean definitions and even
-supports Spring's XML configuration namespaces. It also allows for importing XML
-bean definition files through an `importBeans` directive.
-
-
-
-[[beans-factory-client]]
-== Using the Container
-
-The `ApplicationContext` is the interface for an advanced factory capable of maintaining
-a registry of different beans and their dependencies. By using the method
-`T getBean(String name, Class<T> requiredType)`, you can retrieve instances of your beans.
-
-The `ApplicationContext` lets you read bean definitions and access them, as the following
-example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	// create and configure beans
-	ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
-
-	// retrieve configured instance
-	PetStoreService service = context.getBean("petStore", PetStoreService.class);
-
-	// use configured instance
-	List<String> userList = service.getUsernameList();
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-    import org.springframework.beans.factory.getBean
-
-	// create and configure beans
-    val context = ClassPathXmlApplicationContext("services.xml", "daos.xml")
-
-    // retrieve configured instance
-    val service = context.getBean<PetStoreService>("petStore")
-
-    // use configured instance
-    var userList = service.getUsernameList()
-----
-======
-
-With Groovy configuration, bootstrapping looks very similar. It has a different context
-implementation class which is Groovy-aware (but also understands XML bean definitions).
-The following example shows Groovy configuration:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	ApplicationContext context = new GenericGroovyApplicationContext("services.groovy", "daos.groovy");
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-val context = GenericGroovyApplicationContext("services.groovy", "daos.groovy")
-----
-======
-
-The most flexible variant is `GenericApplicationContext` in combination with reader
-delegates -- for example, with `XmlBeanDefinitionReader` for XML files, as the following
-example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	GenericApplicationContext context = new GenericApplicationContext();
-	new XmlBeanDefinitionReader(context).loadBeanDefinitions("services.xml", "daos.xml");
-	context.refresh();
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val context = GenericApplicationContext()
-	XmlBeanDefinitionReader(context).loadBeanDefinitions("services.xml", "daos.xml")
-	context.refresh()
-----
-======
-
-You can also use the `GroovyBeanDefinitionReader` for Groovy files, as the following
-example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	GenericApplicationContext context = new GenericApplicationContext();
-	new GroovyBeanDefinitionReader(context).loadBeanDefinitions("services.groovy", "daos.groovy");
-	context.refresh();
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val context = GenericApplicationContext()
-	GroovyBeanDefinitionReader(context).loadBeanDefinitions("services.groovy", "daos.groovy")
-	context.refresh()
-----
-======
-
-You can mix and match such reader delegates on the same `ApplicationContext`,
-reading bean definitions from diverse configuration sources.
-
-You can then use `getBean` to retrieve instances of your beans. The `ApplicationContext`
-interface has a few other methods for retrieving beans, but, ideally, your application
-code should never use them. Indeed, your application code should have no calls to the
-`getBean()` method at all and thus have no dependency on Spring APIs at all. For example,
-Spring's integration with web frameworks provides dependency injection for various web
-framework components such as controllers and JSF-managed beans, letting you declare
-a dependency on a specific bean through metadata (such as an autowiring annotation).
-
-
-
-

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

@@ -1,171 +0,0 @@
-[[beans-beanfactory]]
-= The `BeanFactory` API
-
-The `BeanFactory` API provides the underlying basis for Spring's IoC functionality.
-Its specific contracts are mostly used in integration with other parts of Spring and
-related third-party frameworks, and its `DefaultListableBeanFactory` implementation
-is a key delegate within the higher-level `GenericApplicationContext` container.
-
-`BeanFactory` and related interfaces (such as `BeanFactoryAware`, `InitializingBean`,
-`DisposableBean`) are important integration points for other framework components.
-By not requiring any annotations or even reflection, they allow for very efficient
-interaction between the container and its components. Application-level beans may
-use the same callback interfaces but typically prefer declarative dependency
-injection instead, either through annotations or through programmatic configuration.
-
-Note that the core `BeanFactory` API level and its `DefaultListableBeanFactory`
-implementation do not make assumptions about the configuration format or any
-component annotations to be used. All of these flavors come in through extensions
-(such as `XmlBeanDefinitionReader` and `AutowiredAnnotationBeanPostProcessor`) and
-operate on shared `BeanDefinition` objects as a core metadata representation.
-This is the essence of what makes Spring's container so flexible and extensible.
-
-
-
-[[context-introduction-ctx-vs-beanfactory]]
-== `BeanFactory` or `ApplicationContext`?
-
-This section explains the differences between the `BeanFactory` and
-`ApplicationContext` container levels and the implications on bootstrapping.
-
-You should use an `ApplicationContext` unless you have a good reason for not doing so, with
-`GenericApplicationContext` and its subclass `AnnotationConfigApplicationContext`
-as the common implementations for custom bootstrapping. These are the primary entry
-points to Spring's core container for all common purposes: loading of configuration
-files, triggering a classpath scan, programmatically registering bean definitions
-and annotated classes, and (as of 5.0) registering functional bean definitions.
-
-Because an `ApplicationContext` includes all the functionality of a `BeanFactory`, it is
-generally recommended over a plain `BeanFactory`, except for scenarios where full
-control over bean processing is needed. Within an `ApplicationContext` (such as the
-`GenericApplicationContext` implementation), several kinds of beans are detected
-by convention (that is, by bean name or by bean type -- in particular, post-processors),
-while a plain `DefaultListableBeanFactory` is agnostic about any special beans.
-
-For many extended container features, such as annotation processing and AOP proxying,
-the xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp[`BeanPostProcessor` extension point] is essential.
-If you use only a plain `DefaultListableBeanFactory`, such post-processors do not
-get detected and activated by default. This situation could be confusing, because
-nothing is actually wrong with your bean configuration. Rather,  in such a scenario,
-the container needs to be fully bootstrapped through additional setup.
-
-The following table lists features provided by the `BeanFactory` and
-`ApplicationContext` interfaces and implementations.
-
-[[context-introduction-ctx-vs-beanfactory-feature-matrix]]
-.Feature Matrix
-[cols="50%,25%,25%"]
-|===
-| Feature | `BeanFactory` | `ApplicationContext`
-
-| Bean instantiation/wiring
-| Yes
-| Yes
-
-| Integrated lifecycle management
-| No
-| Yes
-
-| Automatic `BeanPostProcessor` registration
-| No
-| Yes
-
-| Automatic `BeanFactoryPostProcessor` registration
-| No
-| Yes
-
-| Convenient `MessageSource` access (for internationalization)
-| No
-| Yes
-
-| Built-in `ApplicationEvent` publication mechanism
-| No
-| Yes
-|===
-
-To explicitly register a bean post-processor with a `DefaultListableBeanFactory`,
-you need to programmatically call `addBeanPostProcessor`, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
-	// populate the factory with bean definitions
-
-	// now register any needed BeanPostProcessor instances
-	factory.addBeanPostProcessor(new AutowiredAnnotationBeanPostProcessor());
-	factory.addBeanPostProcessor(new MyBeanPostProcessor());
-
-	// now start using the factory
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val factory = DefaultListableBeanFactory()
-	// populate the factory with bean definitions
-
-	// now register any needed BeanPostProcessor instances
-	factory.addBeanPostProcessor(AutowiredAnnotationBeanPostProcessor())
-	factory.addBeanPostProcessor(MyBeanPostProcessor())
-
-	// now start using the factory
-----
-======
-
-To apply a `BeanFactoryPostProcessor` to a plain `DefaultListableBeanFactory`,
-you need to call its `postProcessBeanFactory` method, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
-	XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
-	reader.loadBeanDefinitions(new FileSystemResource("beans.xml"));
-
-	// bring in some property values from a Properties file
-	PropertySourcesPlaceholderConfigurer cfg = new PropertySourcesPlaceholderConfigurer();
-	cfg.setLocation(new FileSystemResource("jdbc.properties"));
-
-	// now actually do the replacement
-	cfg.postProcessBeanFactory(factory);
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val factory = DefaultListableBeanFactory()
-	val reader = XmlBeanDefinitionReader(factory)
-	reader.loadBeanDefinitions(FileSystemResource("beans.xml"))
-
-	// bring in some property values from a Properties file
-	val cfg = PropertySourcesPlaceholderConfigurer()
-	cfg.setLocation(FileSystemResource("jdbc.properties"))
-
-	// now actually do the replacement
-	cfg.postProcessBeanFactory(factory)
-----
-======
-
-In both cases, the explicit registration steps are inconvenient, which is
-why the various `ApplicationContext` variants are preferred over a plain
-`DefaultListableBeanFactory` in Spring-backed applications, especially when
-relying on `BeanFactoryPostProcessor` and `BeanPostProcessor` instances for extended
-container functionality in a typical enterprise setup.
-
-[NOTE]
-====
-An `AnnotationConfigApplicationContext` has all common annotation post-processors
-registered and may bring in additional processors underneath the
-covers through configuration annotations, such as `@EnableTransactionManagement`.
-At the abstraction level of Spring's annotation-based configuration model,
-the notion of bean post-processors becomes a mere internal container detail.
-====

framework-docs/modules/ROOT/pages/core/beans/child-bean-definitions.adoc

@@ -1,84 +0,0 @@
-[[beans-child-bean-definitions]]
-= Bean Definition Inheritance
-
-A bean definition can contain a lot of configuration information, including constructor
-arguments, property values, and container-specific information, such as the initialization
-method, a static factory method name, and so on. A child bean definition inherits
-configuration data from a parent definition. The child definition can override some
-values or add others as needed. Using parent and child bean definitions can save a lot
-of typing. Effectively, this is a form of templating.
-
-If you work with an `ApplicationContext` interface programmatically, child bean
-definitions are represented by the `ChildBeanDefinition` class. Most users do not work
-with them on this level. Instead, they configure bean definitions declaratively in a class
-such as the `ClassPathXmlApplicationContext`. When you use XML-based configuration
-metadata, you can indicate a child bean definition by using the `parent` attribute,
-specifying the parent bean as the value of this attribute. The following example shows how
-to do so:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="inheritedTestBean" abstract="true"
-			class="org.springframework.beans.TestBean">
-		<property name="name" value="parent"/>
-		<property name="age" value="1"/>
-	</bean>
-
-	<bean id="inheritsWithDifferentClass"
-			class="org.springframework.beans.DerivedTestBean"
-			parent="inheritedTestBean" init-method="initialize">  <1>
-		<property name="name" value="override"/>
-		<!-- the age property value of 1 will be inherited from parent -->
-	</bean>
-----
-<1> Note the `parent` attribute.
-
-A child bean definition uses the bean class from the parent definition if none is
-specified but can also override it. In the latter case, the child bean class must be
-compatible with the parent (that is, it must accept the parent's property values).
-
-A child bean definition inherits scope, constructor argument values, property values, and
-method overrides from the parent, with the option to add new values. Any scope, initialization
-method, destroy method, or `static` factory method settings that you specify
-override the corresponding parent settings.
-
-The remaining settings are always taken from the child definition: depends on,
-autowire mode, dependency check, singleton, and lazy init.
-
-The preceding example explicitly marks the parent bean definition as abstract by using
-the `abstract` attribute. If the parent definition does not specify a class, explicitly
-marking the parent bean definition as `abstract` is required, as the following example
-shows:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="inheritedTestBeanWithoutClass" abstract="true">
-		<property name="name" value="parent"/>
-		<property name="age" value="1"/>
-	</bean>
-
-	<bean id="inheritsWithClass" class="org.springframework.beans.DerivedTestBean"
-			parent="inheritedTestBeanWithoutClass" init-method="initialize">
-		<property name="name" value="override"/>
-		<!-- age will inherit the value of 1 from the parent bean definition-->
-	</bean>
-----
-
-The parent bean cannot be instantiated on its own because it is incomplete, and it is
-also explicitly marked as `abstract`. When a definition is `abstract`, it is
-usable only as a pure template bean definition that serves as a parent definition for
-child definitions. Trying to use such an `abstract` parent bean on its own, by referring
-to it as a ref property of another bean or doing an explicit `getBean()` call with the
-parent bean ID returns an error. Similarly, the container's internal
-`preInstantiateSingletons()` method ignores bean definitions that are defined as
-abstract.
-
-NOTE: `ApplicationContext` pre-instantiates all singletons by default. Therefore, it is
-important (at least for singleton beans) that if you have a (parent) bean definition
-which 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 will actually (attempt to) pre-instantiate the `abstract` bean.
-
-
-
-