Release v6.0.10

2026-06-08 17:33:33 +00:00 · 2023-06-15 08:19:28 +00:00
2708 changed files with 39108 additions and 94621 deletions
@@ -21,7 +21,8 @@ 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/
@@ -0,0 +1,36 @@
+Juergen Hoeller <jhoeller@vmware.com>
+Juergen Hoeller <jhoeller@vmware.com> <jhoeller@pivotal.io>
+Juergen Hoeller <jhoeller@vmware.com> <jhoeller@gopivotal.com>
+Rossen Stoyanchev <rstoyanchev@vmware.com>
+Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@pivotal.io>
+Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@gopivotal.com>
+Phillip Webb <pwebb@vmware.com>
+Phillip Webb <pwebb@vmware.com> <pwebb@pivotal.io>
+Phillip Webb <pwebb@vmware.com> <pwebb@gopivotal.com>
+Chris Beams <cbeams@vmware.com>
+Chris Beams <cbeams@vmware.com> <cbeams@pivotal.io>
+Chris Beams <cbeams@vmware.com> <cbeams@gopivotal.com>
+Arjen Poutsma <poutsmaa@vmware.com>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@pivotal.io>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@gopivotal.com>
+Arjen Poutsma <poutsmaa@vmware.com> <poutsma@mac.com>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@vmware.com>
+Oliver Drotbohm <odrotbohm@vmware.com>
+Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@vmware.com>
+Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@pivotal.io>
+Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@gopivotal.com>
+Dave Syer <dsyer@vmware.com>
+Dave Syer <dsyer@vmware.com> <dsyer@pivotal.io>
+Dave Syer <dsyer@vmware.com> <dsyer@gopivotal.com>
+Dave Syer <dsyer@vmware.com> <david_syer@hotmail.com>
+Andy Clement <aclement@vmware.com>
+Andy Clement <aclement@vmware.com> <aclement@pivotal.io>
+Andy Clement <aclement@vmware.com> <aclement@gopivotal.com>
+Andy Clement <aclement@vmware.com> <andrew.clement@gmail.com>
+Sam Brannen <sbrannen@vmware.com>
+Sam Brannen <sbrannen@vmware.com> <sbrannen@pivotal.io>
+Sam Brannen <sbrannen@vmware.com> <sam@sambrannen.com>
+Simon Basle <sbasle@vmware.com>
+Simon Baslé <sbasle@vmware.com>
+<dmitry.katsubo@gmail.com> <dmitry.katsubo@gmai.com>
+Nick Williams <nicholas@nicholaswilliams.net>
@@ -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.8.1-librca
+java=17.0.7-librca
@@ -123,13 +123,13 @@ define the source file coding standards we use along with some IDEA editor setti

 ### Reference Docs

-The reference documentation is authored in [Asciidoctor](https://asciidoctor.org/) format
-using [Antora](https://docs.antora.org/antora/latest/). The source files for the documentation
-reside in the [framework-docs/modules/ROOT](framework-docs/modules/ROOT) directory. For
-trivial changes, you may be able to browse, edit source files, and submit directly from GitHub.
+The reference documentation is in the [framework-docs/src/docs/asciidoc](framework-docs/src/docs/asciidoc) directory, in
+[Asciidoctor](https://asciidoctor.org/) format. For trivial changes, you may be able to browse,
+edit source files, and submit directly from GitHub.

-When making changes locally, execute `./gradlew antora` and then browse the results under
-`framework-docs/build/site/index.html`.
+When making changes locally, execute `./gradlew :framework-docs:asciidoctor` and then browse the result under
+`framework-docs/build/docs/ref-docs/html5/index.html`.

 Asciidoctor also supports live editing. For more details see
 [AsciiDoc Tooling](https://docs.asciidoctor.org/asciidoctor/latest/tooling/).
+
@@ -1,8 +1,8 @@
-# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-6.1.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.1.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
+# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-6.0.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)

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

-Spring provides everything required beyond the Java programming language for creating enterprise applications for a wide range of scenarios and architectures. Please read the [Overview](https://docs.spring.io/spring-framework/reference/overview.html) section of the reference documentation for a more complete introduction.
+Spring provides everything required beyond the Java programming language for creating enterprise applications for a wide range of scenarios and architectures. Please read the [Overview](https://docs.spring.io/spring/docs/current/spring-framework-reference/overview.html#spring-introduction) section as reference for a more complete introduction.

 ## Code of Conduct

@@ -14,7 +14,7 @@ For access to artifacts or a distribution zip, see the [Spring Framework Artifac

 ## Documentation

-The Spring Framework maintains reference documentation ([published](https://docs.spring.io/spring-framework/reference/) and [source](framework-docs/modules/ROOT)), GitHub [wiki pages](https://github.com/spring-projects/spring-framework/wiki), and an
+The Spring Framework maintains reference documentation ([published](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/) and [source](framework-docs/src/docs/asciidoc)), GitHub [wiki pages](https://github.com/spring-projects/spring-framework/wiki), and an
 [API reference](https://docs.spring.io/spring-framework/docs/current/javadoc-api/). There are also [guides and tutorials](https://spring.io/guides) across Spring projects.

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

 ## Stay in Touch

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

 ## License

@@ -1,26 +1,22 @@
 plugins {
-	id 'io.freefair.aspectj' version '8.4' apply false
+	id 'io.spring.nohttp' version '0.0.11'
+	id 'io.freefair.aspectj' version '8.0.1' apply false
 	// kotlinVersion is managed in gradle.properties
 	id 'org.jetbrains.kotlin.plugin.serialization' version "${kotlinVersion}" apply false
-	id 'org.jetbrains.dokka' version '1.8.20'
+	id 'org.jetbrains.dokka' version '1.8.10'
 	id 'org.unbroken-dome.xjc' version '2.0.0' apply false
-	id 'com.github.ben-manes.versions' version '0.49.0'
+	id 'com.github.ben-manes.versions' version '0.46.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 'me.champeau.mrjar' version '0.1.1'
+	id 'me.champeau.jmh' version '0.7.0' apply false
 }

 ext {
 	moduleProjects = subprojects.findAll { it.name.startsWith("spring-") }
-	javaProjects = subprojects.findAll { !it.name.startsWith("framework-") }
+	javaProjects = subprojects - project(":framework-bom") - project(":framework-platform")
 }

-description = "Spring Framework"
-
 configure(allprojects) { project ->
-	apply plugin: "org.springframework.build.localdev"
-	group = "org.springframework"
 	repositories {
 		mavenCentral()
 		maven {
@@ -45,7 +41,16 @@ configure(allprojects) { project ->
 	}
 }

-configure(allprojects - project(":framework-platform")) {
+configure([rootProject] + javaProjects) { project ->
+	group = "org.springframework"
+
+	apply plugin: "java"
+	apply plugin: "java-test-fixtures"
+	apply plugin: "checkstyle"
+	apply plugin: 'org.springframework.build.conventions'
+	apply from: "${rootDir}/gradle/toolchains.gradle"
+	apply from: "${rootDir}/gradle/ide.gradle"
+
 	configurations {
 		dependencyManagement {
 			canBeConsumed = false
@@ -54,19 +59,36 @@ configure(allprojects - project(":framework-platform")) {
 		}
 		matching { it.name.endsWith("Classpath") }.all { it.extendsFrom(dependencyManagement) }
 	}
+
+	test {
+		useJUnitPlatform()
+		include(["**/*Tests.class", "**/*Test.class"])
+		systemProperty("java.awt.headless", "true")
+		systemProperty("testGroups", project.properties.get("testGroups"))
+		systemProperty("io.netty.leakDetection.level", "paranoid")
+		systemProperty("io.netty5.leakDetectionLevel", "paranoid")
+		systemProperty("io.netty5.leakDetection.targetRecords", "32")
+		systemProperty("io.netty5.buffer.lifecycleTracingEnabled", "true")
+		systemProperty("io.netty5.buffer.leakDetectionEnabled", "true")
+		jvmArgs(["--add-opens=java.base/java.lang=ALL-UNNAMED",
+				 "--add-opens=java.base/java.util=ALL-UNNAMED"])
+	}
+
+	checkstyle {
+		toolVersion = "10.12.0"
+		configDirectory.set(rootProject.file("src/checkstyle"))
+	}
+
+	tasks.named("checkstyleMain").configure {
+		maxHeapSize = "1g"
+	}
+
+	tasks.named("checkstyleTest").configure {
+		maxHeapSize = "1g"
+	}
+
 	dependencies {
 		dependencyManagement(enforcedPlatform(dependencies.project(path: ":framework-platform")))
-	}
-}
-
-configure([rootProject] + javaProjects) { project ->
-	apply plugin: "java"
-	apply plugin: "java-test-fixtures"
-	apply plugin: 'org.springframework.build.conventions'
-	apply from: "${rootDir}/gradle/toolchains.gradle"
-	apply from: "${rootDir}/gradle/ide.gradle"
-
-	dependencies {
 		testImplementation("org.junit.jupiter:junit-jupiter-api")
 		testImplementation("org.junit.jupiter:junit-jupiter-params")
 		testImplementation("org.junit.platform:junit-platform-suite-api")
@@ -84,6 +106,7 @@ configure([rootProject] + javaProjects) { project ->
 		// JSR-305 only used for non-required meta-annotations
 		compileOnly("com.google.code.findbugs:jsr305")
 		testCompileOnly("com.google.code.findbugs:jsr305")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.38")
 	}

 	ext.javadocLinks = [
@@ -93,28 +116,56 @@ configure([rootProject] + javaProjects) { project ->
 			"https://www.ibm.com/docs/api/v1/content/SSEQTP_8.5.5/com.ibm.websphere.javadoc.doc/web/apidocs/", // com.ibm.*
 			"https://docs.jboss.org/jbossas/javadoc/4.0.5/connector/", // org.jboss.resource.*
 			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
-			"https://eclipse.dev/aspectj/doc/released/aspectj5rt-api",
+			"https://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
 			"https://www.quartz-scheduler.org/api/2.3.0/",
-			"https://fasterxml.github.io/jackson-core/javadoc/2.14/",
-			"https://fasterxml.github.io/jackson-databind/javadoc/2.14/",
-			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.14/",
+			"https://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://hc.apache.org/httpcomponents-client-5.2.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
 			// TODO Uncomment link to JUnit 5 docs once we execute Gradle with Java 18+.
 			// See https://github.com/spring-projects/spring-framework/issues/27497
 			//
-			// "https://junit.org/junit5/docs/5.10.1/api/",
+			// "https://junit.org/junit5/docs/5.9.3/api/",
 			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
-			//"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
+			"https://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.
-			//"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/"
+			"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/"
 	] as String[]
 }

 configure(moduleProjects) { project ->
 	apply from: "${rootDir}/gradle/spring-module.gradle"
 }
+
+configure(rootProject) {
+	description = "Spring Framework"
+
+	apply plugin: "io.spring.nohttp"
+	apply plugin: 'org.springframework.build.api-diff'
+
+	nohttp {
+		source.exclude "**/test-output/**"
+		source.exclude "**/.gradle/**"
+		allowlistFile = project.file("src/nohttp/allowlist.lines")
+		def rootPath = file(rootDir).toPath()
+		def projectDirs = allprojects.collect { it.projectDir } + "${rootDir}/buildSrc"
+		projectDirs.forEach { dir ->
+			[ 'bin', 'build', 'out', '.settings' ]
+				.collect { rootPath.relativize(new File(dir, it).toPath()) }
+				.forEach { source.exclude "$it/**" }
+			[ '.classpath', '.project' ]
+				.collect { rootPath.relativize(new File(dir, it).toPath()) }
+				.forEach { source.exclude "$it" }
+		}
+	}
+
+	tasks.named("checkstyleNohttp").configure {
+		maxHeapSize = "1g"
+	}
+
+}
@@ -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

@@ -1,6 +1,5 @@
 plugins {
 	id 'java-gradle-plugin'
-	id 'checkstyle'
 }

 repositories {
@@ -18,24 +17,22 @@ ext {
 }

 dependencies {
-	checkstyle "io.spring.javaformat:spring-javaformat-checkstyle:${javaFormatVersion}"
-	implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
-	implementation "org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}"
-	implementation "org.gradle:test-retry-gradle-plugin:1.5.6"
-	implementation "io.spring.javaformat:spring-javaformat-gradle-plugin:${javaFormatVersion}"
-	implementation "io.spring.nohttp:nohttp-gradle:0.0.11"
+	implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
+	implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}")
+	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.3.0"
+	implementation "org.gradle:test-retry-gradle-plugin:1.4.1"
 }

 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"
 		}
-		localDevPlugin {
-			id = "org.springframework.build.localdev"
-			implementationClass = "org.springframework.build.dev.LocalDevelopmentPlugin"
-		}
 		optionalDependenciesPlugin {
 			id = "org.springframework.build.optional-dependencies"
 			implementationClass = "org.springframework.build.optional.OptionalDependenciesPlugin"
@@ -1,27 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE module PUBLIC "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN" "https://checkstyle.org/dtds/configuration_1_3.dtd">
-<module name="com.puppycrawl.tools.checkstyle.Checker">
-
-	<!-- Root Checks -->
-	<module name="io.spring.javaformat.checkstyle.check.SpringHeaderCheck">
-		<property name="fileExtensions" value="java"/>
-		<property name="headerType" value="apache2"/>
-		<property name="headerCopyrightPattern" value="20\d\d-20\d\d"/>
-		<property name="packageInfoHeaderType" value="none"/>
-	</module>
-	<module name="com.puppycrawl.tools.checkstyle.checks.NewlineAtEndOfFileCheck"/>
-
-	<!-- TreeWalker Checks -->
-	<module name="com.puppycrawl.tools.checkstyle.TreeWalker">
-
-		<!-- Imports -->
-		<module name="com.puppycrawl.tools.checkstyle.checks.imports.UnusedImportsCheck">
-			<property name="processJavadoc" value="true"/>
-		</module>
-
-		<!-- Modifiers -->
-		<module name="com.puppycrawl.tools.checkstyle.checks.modifier.ModifierOrderCheck"/>
-
-	</module>
-
-</module>
@@ -1,2 +1 @@
 org.gradle.caching=true
-javaFormatVersion=0.0.39
@@ -1,79 +0,0 @@
-/*
- * Copyright 2002-2023 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build;
-
-import java.io.File;
-import java.nio.file.Path;
-import java.util.List;
-
-import io.spring.javaformat.gradle.SpringJavaFormatPlugin;
-import io.spring.nohttp.gradle.NoHttpExtension;
-import io.spring.nohttp.gradle.NoHttpPlugin;
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.DependencySet;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.gradle.api.plugins.quality.Checkstyle;
-import org.gradle.api.plugins.quality.CheckstyleExtension;
-import org.gradle.api.plugins.quality.CheckstylePlugin;
-
-/**
- * {@link Plugin} that applies conventions for checkstyle.
- *
- * @author Brian Clozel
- */
-public class CheckstyleConventions {
-
-	/**
-	 * Applies the Spring Java Format and Checkstyle plugins with the project conventions.
-	 * @param project the current project
-	 */
-	public void apply(Project project) {
-		project.getPlugins().withType(JavaBasePlugin.class, (java) -> {
-			if (project.getRootProject() == project) {
-				configureNoHttpPlugin(project);
-			}
-			project.getPlugins().apply(CheckstylePlugin.class);
-			project.getTasks().withType(Checkstyle.class).forEach(checkstyle -> checkstyle.getMaxHeapSize().set("1g"));
-			CheckstyleExtension checkstyle = project.getExtensions().getByType(CheckstyleExtension.class);
-			checkstyle.setToolVersion("10.12.5");
-			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
-			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
-			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
-			checkstyleDependencies
-				.add(project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
-		});
-	}
-
-	private static void configureNoHttpPlugin(Project project) {
-		project.getPlugins().apply(NoHttpPlugin.class);
-		NoHttpExtension noHttp = project.getExtensions().getByType(NoHttpExtension.class);
-		noHttp.setAllowlistFile(project.file("src/nohttp/allowlist.lines"));
-		noHttp.getSource().exclude("**/test-output/**", "**/.settings/**",
-				"**/.classpath", "**/.project", "**/.gradle/**");
-		List<String> buildFolders = List.of("bin", "build", "out");
-		project.allprojects(subproject -> {
-			Path rootPath = project.getRootDir().toPath();
-			Path projectPath = rootPath.relativize(subproject.getProjectDir().toPath());
-			for (String buildFolder : buildFolders) {
-				Path innerBuildDir = projectPath.resolve(buildFolder);
-				noHttp.getSource().exclude(innerBuildDir + File.separator + "**");
-			}
-		});
-	}
-
-}
@@ -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.
@@ -25,8 +25,10 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin;
 * Plugin to apply conventions to projects that are part of Spring Framework's build.
 * Conventions are applied in response to various plugins being applied.
 *
- * <p>When the {@link JavaBasePlugin} is applied, the conventions in {@link CheckstyleConventions},
- * {@link TestConventions} and {@link JavaConventions} are applied.
+ * When the {@link JavaBasePlugin} is applied, the conventions in {@link TestConventions}
+ * are applied.
+ * When the {@link JavaBasePlugin} is applied, the conventions in {@link JavaConventions}
+ * are applied.
 * When the {@link KotlinBasePlugin} is applied, the conventions in {@link KotlinConventions}
 * are applied.
 *
@@ -36,10 +38,8 @@ public class ConventionsPlugin implements Plugin<Project> {

 	@Override
 	public void apply(Project project) {
-		new CheckstyleConventions().apply(project);
 		new JavaConventions().apply(project);
 		new KotlinConventions().apply(project);
 		new TestConventions().apply(project);
 	}
-
 }
@@ -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.
@@ -24,10 +24,7 @@ import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.plugins.JavaBasePlugin;
 import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.compile.JavaCompile;
-import org.gradle.jvm.toolchain.JavaLanguageVersion;
-import org.gradle.jvm.toolchain.JvmVendorSpec;

 /**
 * {@link Plugin} that applies conventions for compiling Java sources in Spring Framework.
@@ -71,10 +68,6 @@ public class JavaConventions {
 	 * @param project the current project
 	 */
 	private void applyJavaCompileConventions(Project project) {
-		project.getExtensions().getByType(JavaPluginExtension.class).toolchain(toolchain -> {
-			toolchain.getVendor().set(JvmVendorSpec.BELLSOFT);
-			toolchain.getLanguageVersion().set(JavaLanguageVersion.of(17));
-		});
 		project.getTasks().withType(JavaCompile.class)
 				.matching(compileTask -> compileTask.getName().equals(JavaPlugin.COMPILE_JAVA_TASK_NAME))
 				.forEach(compileTask -> {
@@ -16,8 +16,6 @@

 package org.springframework.build;

-import java.util.Map;
-
 import org.gradle.api.Project;
 import org.gradle.api.plugins.JavaBasePlugin;
 import org.gradle.api.tasks.testing.Test;
@@ -43,36 +41,11 @@ class TestConventions {

 	private void configureTestConventions(Project project) {
 		project.getTasks().withType(Test.class,
-				test -> {
-					configureTests(project, test);
-					configureTestRetryPlugin(project, test);
-				});
-	}
-
-	private void configureTests(Project project, Test test) {
-		test.useJUnitPlatform();
-		test.include("**/*Tests.class", "**/*Test.class");
-		test.setSystemProperties(Map.of(
-				"java.awt.headless", "true",
-				"io.netty.leakDetection.level", "paranoid",
-				"io.netty5.leakDetectionLevel", "paranoid",
-				"io.netty5.leakDetection.targetRecords", "32",
-				"io.netty5.buffer.lifecycleTracingEnabled", "true"
-		));
-		if (project.hasProperty("testGroups")) {
-			test.systemProperty("testGroups", project.getProperties().get("testGroups"));
-		}
-		test.jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED",
-				"--add-opens=java.base/java.util=ALL-UNNAMED",
-				"-Djava.locale.providers=COMPAT");
-	}
-
-	private void configureTestRetryPlugin(Project project, Test test) {
-		project.getPlugins().withType(TestRetryPlugin.class, testRetryPlugin -> {
-			TestRetryTaskExtension testRetry = test.getExtensions().getByType(TestRetryTaskExtension.class);
-			testRetry.getFailOnPassedAfterRetry().set(true);
-			testRetry.getMaxRetries().set(isCi() ? 3 : 0);
-		});
+				test -> project.getPlugins().withType(TestRetryPlugin.class, testRetryPlugin -> {
+					TestRetryTaskExtension testRetry = test.getExtensions().getByType(TestRetryTaskExtension.class);
+					testRetry.getFailOnPassedAfterRetry().set(true);
+					testRetry.getMaxRetries().set(isCi() ? 3 : 0);
+				}));
 	}

 	private boolean isCi() {
@@ -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());
+	}
+
+}
@@ -1,49 +0,0 @@
-/*
- * Copyright 2002-2023 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.dev;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaBasePlugin;
-
-/**
- * {@link Plugin} that skips documentation tasks when the {@code "-PskipDocs"} property is defined.
- *
- * @author Brian Clozel
- */
-public class LocalDevelopmentPlugin implements Plugin<Project> {
-
-	private static final String SKIP_DOCS_PROPERTY = "skipDocs";
-
-	@Override
-	public void apply(Project target) {
-		if (target.hasProperty(SKIP_DOCS_PROPERTY)) {
-			skipDocumentationTasks(target);
-			target.subprojects(this::skipDocumentationTasks);
-		}
-	}
-
-	private void skipDocumentationTasks(Project project) {
-		project.afterEvaluate(p -> {
-			p.getTasks().matching(task -> {
-						return JavaBasePlugin.DOCUMENTATION_GROUP.equals(task.getGroup())
-								|| "distribution".equals(task.getGroup());
-					})
-					.forEach(task -> task.setEnabled(false));
-		});
-	}
-}
@@ -1,48 +0,0 @@
-/*
- * Copyright 2002-2023 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.hint;
-
-import java.util.Collections;
-
-import org.gradle.api.file.ConfigurableFileCollection;
-import org.gradle.api.provider.SetProperty;
-import org.gradle.api.tasks.Classpath;
-import org.gradle.api.tasks.Input;
-import org.gradle.process.CommandLineArgumentProvider;
-
-/**
- * Argument provider for registering the runtime hints agent with a Java process.
- */
-public interface RuntimeHintsAgentArgumentProvider extends CommandLineArgumentProvider {
-
-	@Classpath
-	ConfigurableFileCollection getAgentJar();
-
-    @Input
-    SetProperty<String> getIncludedPackages();
-
-    @Input
-    SetProperty<String> getExcludedPackages();
-
-    @Override
-    default Iterable<String> asArguments() {
-        StringBuilder packages = new StringBuilder();
-        getIncludedPackages().get().forEach(packageName -> packages.append('+').append(packageName).append(','));
-        getExcludedPackages().get().forEach(packageName -> packages.append('-').append(packageName).append(','));
-        return Collections.singleton("-javaagent:" + getAgentJar().getSingleFile() + "=" + packages);
-    }
-}
@@ -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.
@@ -16,15 +16,38 @@

 package org.springframework.build.hint;

+import java.util.Collections;
+
+import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.SetProperty;

 /**
 * Entry point to the DSL extension for the {@link RuntimeHintsAgentPlugin} Gradle plugin.
 * @author Brian Clozel
 */
-public interface RuntimeHintsAgentExtension {
+public class RuntimeHintsAgentExtension {

-	SetProperty<String> getIncludedPackages();
+	private final SetProperty<String> includedPackages;

-	SetProperty<String> getExcludedPackages();
+	private final SetProperty<String> excludedPackages;
+
+	public RuntimeHintsAgentExtension(ObjectFactory objectFactory) {
+		this.includedPackages = objectFactory.setProperty(String.class).convention(Collections.singleton("org.springframework"));
+		this.excludedPackages = objectFactory.setProperty(String.class).convention(Collections.emptySet());
+	}
+
+	public SetProperty<String> getIncludedPackages() {
+		return this.includedPackages;
+	}
+
+	public SetProperty<String> getExcludedPackages() {
+		return this.excludedPackages;
+	}
+
+	String asJavaAgentArgument() {
+		StringBuilder builder = new StringBuilder();
+		this.includedPackages.get().forEach(packageName -> builder.append('+').append(packageName).append(','));
+		this.excludedPackages.get().forEach(packageName -> builder.append('-').append(packageName).append(','));
+		return builder.toString();
+	}
 }
@@ -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.
@@ -16,79 +16,41 @@

 package org.springframework.build.hint;

-import org.gradle.api.JavaVersion;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.attributes.Bundling;
-import org.gradle.api.attributes.Category;
-import org.gradle.api.attributes.LibraryElements;
-import org.gradle.api.attributes.Usage;
-import org.gradle.api.attributes.java.TargetJvmVersion;
 import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.tasks.bundling.Jar;
 import org.gradle.api.tasks.testing.Test;

-import java.util.Collections;
-
 /**
 * {@link Plugin} that configures the {@code RuntimeHints} Java agent to test tasks.
 *
 * @author Brian Clozel
- * @author Sebastien Deleuze
 */
 public class RuntimeHintsAgentPlugin implements Plugin<Project> {

 	public static final String RUNTIMEHINTS_TEST_TASK = "runtimeHintsTest";
 	private static final String EXTENSION_NAME = "runtimeHintsAgent";
-	private static final String CONFIGURATION_NAME = "testRuntimeHintsAgentJar";


 	@Override
 	public void apply(Project project) {

 		project.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
-			RuntimeHintsAgentExtension agentExtension = createRuntimeHintsAgentExtension(project);
+			RuntimeHintsAgentExtension agentExtension = project.getExtensions().create(EXTENSION_NAME,
+					RuntimeHintsAgentExtension.class, project.getObjects());
 			Test agentTest = project.getTasks().create(RUNTIMEHINTS_TEST_TASK, Test.class, test -> {
 				test.useJUnitPlatform(options -> {
 					options.includeTags("RuntimeHintsTests");
 				});
 				test.include("**/*Tests.class", "**/*Test.class");
 				test.systemProperty("java.awt.headless", "true");
-				test.systemProperty("org.graalvm.nativeimage.imagecode", "runtime");
-				test.getJvmArgumentProviders().add(createRuntimeHintsAgentArgumentProvider(project, agentExtension));
+			});
+			project.afterEvaluate(p -> {
+				Jar jar = project.getRootProject().project("spring-core-test").getTasks().withType(Jar.class).named("jar").get();
+				agentTest.jvmArgs("-javaagent:" + jar.getArchiveFile().get().getAsFile() + "=" + agentExtension.asJavaAgentArgument());
 			});
 			project.getTasks().getByName("check", task -> task.dependsOn(agentTest));
-			project.getDependencies().add(CONFIGURATION_NAME, project.project(":spring-core-test"));
-		});
-	}
-
-	private static RuntimeHintsAgentExtension createRuntimeHintsAgentExtension(Project project) {
-		RuntimeHintsAgentExtension agentExtension = project.getExtensions().create(EXTENSION_NAME, RuntimeHintsAgentExtension.class);
-		agentExtension.getIncludedPackages().convention(Collections.singleton("org.springframework"));
-		agentExtension.getExcludedPackages().convention(Collections.emptySet());
-		return agentExtension;
-	}
-
-	private static RuntimeHintsAgentArgumentProvider createRuntimeHintsAgentArgumentProvider(
-			Project project, RuntimeHintsAgentExtension agentExtension) {
-		RuntimeHintsAgentArgumentProvider agentArgumentProvider = project.getObjects().newInstance(RuntimeHintsAgentArgumentProvider.class);
-		agentArgumentProvider.getAgentJar().from(createRuntimeHintsAgentConfiguration(project));
-		agentArgumentProvider.getIncludedPackages().set(agentExtension.getIncludedPackages());
-		agentArgumentProvider.getExcludedPackages().set(agentExtension.getExcludedPackages());
-		return agentArgumentProvider;
-	}
-
-	private static Configuration createRuntimeHintsAgentConfiguration(Project project) {
-		return project.getConfigurations().create(CONFIGURATION_NAME, configuration -> {
-			configuration.setCanBeConsumed(false);
-			configuration.setTransitive(false); // Only the built artifact is required
-			configuration.attributes(attributes -> {
-				attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, project.getObjects().named(Bundling.class, Bundling.EXTERNAL));
-				attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, Category.LIBRARY));
-				attributes.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.getObjects().named(LibraryElements.class, LibraryElements.JAR));
-				attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, Integer.valueOf(JavaVersion.current().getMajorVersion()));
-				attributes.attribute(Usage.USAGE_ATTRIBUTE, project.getObjects().named(Usage.class, Usage.JAVA_RUNTIME));
-			});
 		});
 	}
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2021 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.
@@ -19,7 +19,7 @@ package org.springframework.build.optional;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.SourceSetContainer;

@@ -40,10 +40,10 @@ public class OptionalDependenciesPlugin implements Plugin<Project> {

 	@Override
 	public void apply(Project project) {
-		Configuration optional = project.getConfigurations().create(OPTIONAL_CONFIGURATION_NAME);
+		Configuration optional = project.getConfigurations().create("optional");
 		optional.setCanBeConsumed(false);
 		optional.setCanBeResolved(false);
-		project.getPlugins().withType(JavaBasePlugin.class, (javaBasePlugin) -> {
+		project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> {
 			SourceSetContainer sourceSets = project.getExtensions().getByType(JavaPluginExtension.class)
 					.getSourceSets();
 			sourceSets.all((sourceSet) -> {
@@ -53,4 +53,4 @@ public class OptionalDependenciesPlugin implements Plugin<Project> {
 		});
 	}

-}
+}
@@ -1,19 +1,3 @@
-/*
- * Copyright 2002-2023 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package org.springframework.build.shadow;

 import java.io.File;
@@ -1,4 +1,4 @@
-FROM ubuntu:jammy-20231128
+FROM ubuntu:jammy-20230425

 ADD setup.sh /setup.sh
 ADD get-jdk-url.sh /get-jdk-url.sh
@@ -6,7 +6,6 @@ RUN ./setup.sh

 ENV JAVA_HOME /opt/openjdk/java17
 ENV JDK17 /opt/openjdk/java17
-ENV JDK21 /opt/openjdk/java21
-ENV JDK22 /opt/openjdk/java22
+ENV JDK20 /opt/openjdk/java20

 ENV PATH $JAVA_HOME/bin:$PATH
@@ -3,13 +3,10 @@ set -e

 case "$1" in
 	java17)
-		echo "https://download.bell-sw.com/java/17.0.9+11/bellsoft-jdk17.0.9+11-linux-amd64.tar.gz"
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.7+7/bellsoft-jdk17.0.7+7-linux-amd64.tar.gz"
 	;;
-	java21)
-		echo "https://download.bell-sw.com/java/21.0.1+12/bellsoft-jdk21.0.1+12-linux-amd64.tar.gz"
-	;;
-	java22)
-		echo "https://download.java.net/java/early_access/jdk22/27/GPL/openjdk-22-ea+27_linux-x64_bin.tar.gz"
+	java20)
+		echo "https://github.com/bell-sw/Liberica/releases/download/20.0.1+10/bellsoft-jdk20.0.1+10-linux-amd64.tar.gz"
 	;;
 	*)
 		echo $"Unknown java version"
@@ -20,7 +20,7 @@ curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/c

 mkdir -p /opt/openjdk
 pushd /opt/openjdk > /dev/null
-for jdk in java17 java21 java22
+for jdk in java17 java20
 do
  JDK_URL=$( /get-jdk-url.sh $jdk )
  mkdir $jdk
@@ -3,8 +3,8 @@ github-repo-name: "spring-projects/spring-framework"
 sonatype-staging-profile: "org.springframework"
 docker-hub-organization: "springci"
 artifactory-server: "https://repo.spring.io"
-branch: "main"
-milestone: "6.1.x"
+branch: "6.0.x"
+milestone: "6.0.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
 concourse-url: "https://ci.spring.io"
@@ -45,7 +45,7 @@ resource_types:
  source:
    <<: *docker-resource-source
    repository: concourse/registry-image-resource
-    tag: 1.8.0
+    tag: 1.5.0
 - name: artifactory-resource
  type: registry-image
  source:
@@ -57,7 +57,7 @@ resource_types:
  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:
@@ -113,22 +113,14 @@ resources:
    access_token: ((github-ci-status-token))
    branch: ((branch))
    context: build
- name: repo-status-jdk21-build
+- name: repo-status-jdk20-build
  type: github-status-resource
  icon: eye-check-outline
  source:
    repository: ((github-repo-name))
    access_token: ((github-ci-status-token))
    branch: ((branch))
-    context: jdk21-build
- name: repo-status-jdk22-build
-  type: github-status-resource
-  icon: eye-check-outline
-  source:
-    repository: ((github-repo-name))
-    access_token: ((github-ci-status-token))
-    branch: ((branch))
-    context: jdk22-build
+    context: jdk20-build
 - name: slack-alert
  type: slack-notification
  icon: slack
@@ -206,22 +198,26 @@ jobs:
      threads: 8
      artifact_set:
      - include:
-        - "/**/framework-api-*.zip"
+        - "/**/framework-docs-*.zip"
        properties:
          "zip.name": "spring-framework"
          "zip.displayname": "Spring Framework"
          "zip.deployed": "false"
      - include:
-        - "/**/framework-api-*-docs.zip"
+        - "/**/framework-docs-*-docs.zip"
        properties:
          "zip.type": "docs"
      - include:
-        - "/**/framework-api-*-schema.zip"
+        - "/**/framework-docs-*-dist.zip"
+        properties:
+          "zip.type": "dist"
+      - include:
+        - "/**/framework-docs-*-schema.zip"
        properties:
          "zip.type": "schema"
    get_params:
      threads: 8
- name: jdk21-build
+- name: jdk20-build
  serial: true
  public: true
  plan:
@@ -229,7 +225,7 @@ jobs:
    - get: git-repo
    - get: every-morning
      trigger: true
-    - put: repo-status-jdk21-build
+    - put: repo-status-jdk20-build
      params: { state: "pending", commit: "git-repo" }
    - do:
        - task: check-project
@@ -238,42 +234,16 @@ jobs:
          privileged: true
          timeout: ((task-timeout))
          params:
-            TEST_TOOLCHAIN: 21
+            TEST_TOOLCHAIN: 20
            <<: *build-project-task-params
      on_failure:
        do:
-          - put: repo-status-jdk21-build
+          - put: repo-status-jdk20-build
            params: { state: "failure", commit: "git-repo" }
          - put: slack-alert
            params:
              <<: *slack-fail-params
-    - put: repo-status-jdk21-build
-      params: { state: "success", commit: "git-repo" }
- name: jdk22-build
-  serial: true
-  public: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-    - put: repo-status-jdk22-build
-      params: { state: "pending", commit: "git-repo" }
-    - do:
-        - task: check-project
-          image: ci-image
-          file: git-repo/ci/tasks/check-project.yml
-          privileged: true
-          timeout: ((task-timeout))
-          params:
-            TEST_TOOLCHAIN: 22
-            <<: *build-project-task-params
-      on_failure:
-        do:
-          - put: repo-status-jdk22-build
-            params: { state: "failure", commit: "git-repo" }
-          - put: slack-alert
-            params:
-              <<: *slack-fail-params
-    - put: repo-status-jdk22-build
+    - put: repo-status-jdk20-build
      params: { state: "success", commit: "git-repo" }
 - name: stage-milestone
  serial: true
@@ -426,7 +396,7 @@ jobs:

 groups:
 - name: "builds"
-  jobs: ["build", "jdk21-build", "jdk22-build"]
+  jobs: ["build", "jdk20-build"]
 - name: "releases"
  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
 - name: "ci-images"
@@ -4,6 +4,5 @@ set -e
 source $(dirname $0)/common.sh

 pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
-  --no-daemon --max-workers=4 check
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --max-workers=4 check
 popd > /dev/null
@@ -5,6 +5,5 @@ source $(dirname $0)/common.sh
 repository=$(pwd)/distribution-repository

 pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21,JDK22 \
-  --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
 popd > /dev/null
@@ -4,6 +4,6 @@ set -e
 source $(dirname $0)/common.sh

 pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK20 \
  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check antora
 popd > /dev/null
@@ -35,8 +35,7 @@ git add gradle.properties > /dev/null
 git commit -m"Release v$stageVersion" > /dev/null
 git tag -a "v$stageVersion" -m"Release v$stageVersion" > /dev/null

-./gradlew --no-daemon --max-workers=4 -PdeploymentRepository=${repository} -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
-  build publishAllPublicationsToDeploymentRepository
+./gradlew --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository

 git reset --hard HEAD^ > /dev/null
 if [[ $nextVersion != $snapshotVersion ]]; then
@@ -4,7 +4,7 @@ image_resource:
  type: registry-image
  source:
    repository: springio/concourse-release-scripts
-    tag: '0.4.0'
+    tag: '0.3.4'
    username: ((docker-hub-username))
    password: ((docker-hub-password))
 inputs:
@@ -1,119 +0,0 @@
-plugins {
-	id 'java-platform'
-	id 'io.freefair.aggregate-javadoc' version '8.3'
-}
-
-description = "Spring Framework API Docs"
-
-apply from: "${rootDir}/gradle/publications.gradle"
-
-repositories {
-	maven {
-		url "https://repo.spring.io/release"
-	}
-}
-
-dependencies {
-	moduleProjects.each { moduleProject ->
-		javadoc moduleProject
-	}
-}
-
-javadoc {
-	title = "${rootProject.description} ${version} API"
-	options {
-		encoding = "UTF-8"
-		memberLevel = JavadocMemberLevel.PROTECTED
-		author = true
-		header = rootProject.description
-		use = true
-		overview = project.relativePath("$rootProject.rootDir/framework-docs/src/docs/api/overview.html")
-		destinationDir = file("${project.buildDir}/docs/javadoc-api")
-		splitIndex = true
-		links(rootProject.ext.javadocLinks)
-		addBooleanOption('Xdoclint:syntax,reference', true) // only check syntax and reference with doclint
-		addBooleanOption('Werror', true) // fail build on Javadoc warnings
-	}
-	maxMemory = "1024m"
-	doFirst {
-		classpath += files(
-				// ensure the javadoc process can resolve types compiled from .aj sources
-				project(":spring-aspects").sourceSets.main.output
-		)
-		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
-	}
-}
-
-/**
- * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
- */
-rootProject.tasks.dokkaHtmlMultiModule.configure {
-	dependsOn {
-		tasks.named("javadoc")
-	}
-	moduleName.set("spring-framework")
-	outputDirectory.set(project.file("$buildDir/docs/kdoc-api"))
-	includes.from("$rootProject.rootDir/framework-docs/src/docs/api/dokka-overview.md")
-}
-
-/**
- * Zip all Java docs (javadoc & kdoc) into a single archive
- */
-tasks.register('docsZip', Zip) {
-	dependsOn = ['javadoc', rootProject.tasks.dokkaHtmlMultiModule]
-	group = "distribution"
-	description = "Builds -${archiveClassifier} archive containing api and reference " +
-			"for deployment at https://docs.spring.io/spring-framework/docs/."
-
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("docs")
-	from("src/dist") {
-		include "changelog.txt"
-	}
-	from(javadoc) {
-		into "javadoc-api"
-	}
-	from(rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {
-		into "kdoc-api"
-	}
-}
-
-/**
- * Zip all Spring Framework schemas into a single archive
- */
-tasks.register('schemaZip', Zip) {
-	group = "distribution"
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("schema")
-	description = "Builds -${archiveClassifier} archive containing all " +
-			"XSDs for deployment at https://springframework.org/schema."
-	duplicatesStrategy DuplicatesStrategy.EXCLUDE
-	moduleProjects.each { module ->
-		def Properties schemas = new Properties();
-
-		module.sourceSets.main.resources.find {
-			(it.path.endsWith("META-INF/spring.schemas") || it.path.endsWith("META-INF\\spring.schemas"))
-		}?.withInputStream { schemas.load(it) }
-
-		for (def key : schemas.keySet()) {
-			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
-			assert shortName != key
-			File xsdFile = module.sourceSets.main.resources.find {
-				(it.path.endsWith(schemas.get(key)) || it.path.endsWith(schemas.get(key).replaceAll('\\/', '\\\\')))
-			}
-			assert xsdFile != null
-			into(shortName) {
-				from xsdFile.path
-			}
-		}
-	}
-}
-
-publishing {
-	publications {
-		mavenJava(MavenPublication) {
-			artifact docsZip
-			artifact schemaZip
-		}
-	}
-}
@@ -17,73 +17,16 @@ asciidoc:
    # FIXME: the copyright is not removed
    # FIXME: The package is not renamed
    chomp: 'all'
-    fold: 'all'
    include-java: 'example$docs-src/main/java/org/springframework/docs'
-    spring-site: 'https://spring.io'
-    spring-site-blog: '{spring-site}/blog'
-    spring-site-cve: "{spring-site}/security"
-    spring-site-guides: '{spring-site}/guides'
-    spring-site-projects: '{spring-site}/projects'
-    spring-site-tools: "{spring-site}/tools"
-    spring-org: 'spring-projects'
-    spring-github-org: "https://github.com/{spring-org}"
-    spring-framework-github: "https://github.com/{spring-org}/spring-framework"
-    spring-framework-code: '{spring-framework-github}/tree/main'
-    spring-framework-issues: '{spring-framework-github}/issues'
-    spring-framework-wiki: '{spring-framework-github}/wiki'
-    # Docs
+    spring-framework-main-code: 'https://github.com/spring-projects/spring-framework/tree/main'
    docs-site: 'https://docs.spring.io'
-    spring-framework-docs-root: '{docs-site}/spring-framework/docs'
-    spring-framework-api: '{spring-framework-docs-root}/{spring-version}/javadoc-api/org/springframework'
-    spring-framework-api-kdoc: '{spring-framework-docs-root}/{spring-version}/kdoc-api'
-    spring-framework-reference: '{spring-framework-docs-root}/{spring-version}/reference'
-    #
-    # Other Spring portfolio projects
-    spring-boot-docs: '{docs-site}/spring-boot/docs/current/reference/html'
-    spring-boot-issues: '{spring-github-org}/spring-boot/issues'
-    # TODO add more projects / links or just build up on {docs-site}?
-    # TODO rename the below using new conventions
+    docs-spring: "{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'
-    docs-spring-session: '{docs-site}/spring-session/reference'
-    #
-    # External projects URLs and related attributes
-    aspectj-site: 'https://www.eclipse.org/aspectj'
-    aspectj-docs: "{aspectj-site}/doc/released"
-    aspectj-api: "{aspectj-docs}/runtime-api"
-    aspectj-docs-devguide: "{aspectj-docs}/devguide"
-    aspectj-docs-progguide: "{aspectj-docs}/progguide"
-    assertj-docs: 'https://assertj.github.io/doc'
-    baeldung-blog: 'https://www.baeldung.com'
-    bean-validation-site: 'https://beanvalidation.org'
-    graalvm-docs: 'https://www.graalvm.org/22.3/reference-manual'
-    hibernate-validator-site: 'https://hibernate.org/validator/'
-    jackson-docs: 'https://fasterxml.github.io'
-    jackson-github-org: 'https://github.com/FasterXML'
-    java-api: 'https://docs.oracle.com/en/java/javase/17/docs/api'
-    java-tutorial: 'https://docs.oracle.com/javase/tutorial'
-    JSR: 'https://www.jcp.org/en/jsr/detail?id='
-    kotlin-site: 'https://kotlinlang.org'
-    kotlin-docs: '{kotlin-site}/docs'
-    kotlin-api: '{kotlin-site}/api/latest'
-    kotlin-coroutines-api: '{kotlin-site}/api/kotlinx.coroutines'
-    kotlin-github-org: 'https://github.com/Kotlin'
-    kotlin-issues: 'https://youtrack.jetbrains.com/issue'
-    reactive-streams-site: 'https://www.reactive-streams.org'
-    reactive-streams-spec: 'https://github.com/reactive-streams/reactive-streams-jvm/blob/master/README.md#specification'
-    reactor-github-org: 'https://github.com/reactor'
-    reactor-site: 'https://projectreactor.io'
-    rsocket-github-org: 'https://github.com/rsocket'
-    rsocket-java: '{rsocket-github-org}/rsocket-java'
-    rsocket-java-code: '{rsocket-java}/tree/master/'
-    rsocket-protocol-extensions: '{rsocket-github-org}/rsocket/tree/master/Extensions'
-    rsocket-site: 'https://rsocket.io'
-    rfc-site: 'https://datatracker.ietf.org/doc/html'
-    sockjs-client: 'https://github.com/sockjs/sockjs-client'
-    sockjs-protocol: 'https://github.com/sockjs/sockjs-protocol'
-    sockjs-protocol-site: "https://sockjs.github.io/sockjs-protocol"
-    stackoverflow-site: 'https://stackoverflow.com'
-    stackoverflow-questions: '{stackoverflow-site}/questions'
-    stackoverflow-spring-tag: "{stackoverflow-questions}/tagged/spring"
-    stackoverflow-spring-kotlin-tags: "{stackoverflow-spring-tag}+kotlin"
-    testcontainers-site: 'https://www.testcontainers.org'
+    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'
@@ -6,9 +6,9 @@ plugins {

 description = "Spring Framework Docs"

-apply from: "${rootDir}/gradle/ide.gradle"
 apply from: "${rootDir}/gradle/publications.gradle"

+
 antora {
 	version = '3.2.0-alpha.2'
 	playbook = 'cached-antora-playbook.yml'
@@ -34,16 +34,23 @@ antora {
 	]
 }

+
 tasks.named("generateAntoraYml") {
 	asciidocAttributes = project.provider( {
 		return  ["spring-version": project.version ]
 	} )
 }

-tasks.register("generateAntoraResources") {
+tasks.create("generateAntoraResources") {
 	dependsOn 'generateAntoraYml'
 }

+// Commented out for now:
+// https://github.com/spring-projects/spring-framework/issues/30481
+// tasks.named("check") {
+//	dependsOn 'antora'
+// }
+
 jar {
 	enabled = false
 }
@@ -60,11 +67,166 @@ repositories {

 dependencies {
 	api(project(":spring-context"))
-	api(project(":spring-jms"))
 	api(project(":spring-web"))
-	api("jakarta.jms:jakarta.jms-api")
 	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"
+ */
+task api(type: Javadoc) {
+	group = "Documentation"
+	description = "Generates aggregated Javadoc API documentation."
+	title = "${rootProject.description} ${version} API"
+
+	dependsOn {
+		moduleProjects.collect {
+			it.tasks.getByName("jar")
+		}
+	}
+	doFirst {
+		classpath = files(
+				// ensure the javadoc process can resolve types compiled from .aj sources
+				project(":spring-aspects").sourceSets.main.output
+		)
+		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
+	}
+
+	options {
+		encoding = "UTF-8"
+		memberLevel = JavadocMemberLevel.PROTECTED
+		author = true
+		header = rootProject.description
+		use = true
+		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('Werror', true) // fail build on Javadoc warnings
+	}
+	source moduleProjects.collect { project ->
+		project.sourceSets.main.allJava
+	}
+	maxMemory = "1024m"
+	destinationDir = file("$buildDir/docs/javadoc")
+}
+
+/**
+ * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
+ */
+rootProject.tasks.dokkaHtmlMultiModule.configure {
+	dependsOn {
+		tasks.getByName("api")
+	}
+	moduleName.set("spring-framework")
+	outputDirectory.set(project.file("$buildDir/docs/kdoc"))
+}
+
+/**
+ * Zip all Java docs (javadoc & kdoc) into a single archive
+ */
+task docsZip(type: Zip, dependsOn: ['api', rootProject.tasks.dokkaHtmlMultiModule]) {
+	group = "Distribution"
+	description = "Builds -${archiveClassifier} archive containing api and reference " +
+			"for deployment at https://docs.spring.io/spring-framework/docs/."
+
+	archiveBaseName.set("spring-framework")
+	archiveClassifier.set("docs")
+	from("src/dist") {
+		include "changelog.txt"
+	}
+	from (api) {
+		into "javadoc-api"
+	}
+	from (rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {
+		into "kdoc-api"
+	}
+}
+
+/**
+ * Zip all Spring Framework schemas into a single archive
+ */
+task schemaZip(type: Zip) {
+	group = "Distribution"
+	archiveBaseName.set("spring-framework")
+	archiveClassifier.set("schema")
+	description = "Builds -${archiveClassifier} archive containing all " +
+			"XSDs for deployment at https://springframework.org/schema."
+	duplicatesStrategy DuplicatesStrategy.EXCLUDE
+	moduleProjects.each { module ->
+		def Properties schemas = new Properties();
+
+		module.sourceSets.main.resources.find {
+			(it.path.endsWith("META-INF/spring.schemas") || it.path.endsWith("META-INF\\spring.schemas"))
+		}?.withInputStream { schemas.load(it) }
+
+		for (def key : schemas.keySet()) {
+			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
+			assert shortName != key
+			File xsdFile = module.sourceSets.main.resources.find {
+				(it.path.endsWith(schemas.get(key)) || it.path.endsWith(schemas.get(key).replaceAll('\\/','\\\\')))
+			}
+			assert xsdFile != null
+			into (shortName) {
+				from xsdFile.path
+			}
+		}
+	}
+}
+
+/**
+ * Create a distribution zip with everything:
+ * docs, schemas, jars, source jars, javadoc jars
+ */
+task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
+	group = "Distribution"
+	archiveBaseName.set("spring-framework")
+	archiveClassifier.set("dist")
+	description = "Builds -${archiveClassifier} archive, containing all jars and docs, " +
+			"suitable for community download page."
+
+	ext.baseDir = "spring-framework-${project.version}";
+
+	from("src/docs/dist") {
+		include "readme.txt"
+		include "license.txt"
+		include "notice.txt"
+		into "${baseDir}"
+		expand(copyright: new Date().format("yyyy"), version: project.version)
+	}
+
+	from(zipTree(docsZip.archiveFile)) {
+		into "${baseDir}/docs"
+	}
+
+	from(zipTree(schemaZip.archiveFile)) {
+		into "${baseDir}/schema"
+	}
+
+	moduleProjects.each { module ->
+		into ("${baseDir}/libs") {
+			from module.jar
+			if (module.tasks.findByPath("sourcesJar")) {
+				from module.sourcesJar
+			}
+			if (module.tasks.findByPath("javadocJar")) {
+				from module.javadocJar
+			}
+		}
+	}
+}
+
+distZip.mustRunAfter moduleProjects.check
+
+publishing {
+	publications {
+		mavenJava(MavenPublication) {
+			artifact docsZip
+			artifact schemaZip
+			artifact distZip
+		}
+	}
+}
@@ -122,7 +122,6 @@
 **** xref:testing/testcontext-framework/ctx-management/groovy.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/mixed-config.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/initializers.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/inheritance.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/env-profiles.adoc[]
@@ -131,7 +130,6 @@
 **** xref:testing/testcontext-framework/ctx-management/web.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/web-mocks.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/caching.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/failure-threshold.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/hierarchies.adoc[]
 *** xref:testing/testcontext-framework/fixture-di.adoc[]
 *** xref:testing/testcontext-framework/web-scoped-beans.adoc[]
@@ -167,7 +165,6 @@
 ***** xref:testing/annotations/integration-spring/annotation-contextconfiguration.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-webappconfiguration.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-contexthierarchy.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-activeprofiles.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-testpropertysource.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-dynamicpropertysource.adoc[]
@@ -182,7 +179,6 @@
 ***** xref:testing/annotations/integration-spring/annotation-sqlconfig.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-sqlmergemode.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-sqlgroup.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-disabledinaotmode.adoc[]
 **** xref:testing/annotations/integration-junit4.adoc[]
 **** xref:testing/annotations/integration-junit-jupiter.adoc[]
 **** xref:testing/annotations/integration-meta.adoc[]
@@ -270,7 +266,6 @@
 ***** xref:web/webmvc/mvc-controller/ann-methods/jackson.adoc[]
 **** xref:web/webmvc/mvc-controller/ann-modelattrib-methods.adoc[]
 **** xref:web/webmvc/mvc-controller/ann-initbinder.adoc[]
-**** xref:web/webmvc/mvc-controller/ann-validation.adoc[]
 **** xref:web/webmvc/mvc-controller/ann-exceptionhandler.adoc[]
 **** xref:web/webmvc/mvc-controller/ann-advice.adoc[]
 *** xref:web/webmvc-functional.adoc[]
@@ -365,7 +360,6 @@
 ***** xref:web/webflux/controller/ann-methods/jackson.adoc[]
 **** xref:web/webflux/controller/ann-modelattrib-methods.adoc[]
 **** xref:web/webflux/controller/ann-initbinder.adoc[]
-**** xref:web/webflux/controller/ann-validation.adoc[]
 **** xref:web/webflux/controller/ann-exceptions.adoc[]
 **** xref:web/webflux/controller/ann-advice.adoc[]
 *** xref:web/webflux-functional.adoc[]
@@ -420,8 +414,6 @@
 *** xref:integration/cache/plug.adoc[]
 *** xref:integration/cache/specific-config.adoc[]
 ** xref:integration/observability.adoc[]
-** xref:integration/checkpoint-restore.adoc[]
-** xref:integration/class-data-sharing.adoc[]
 ** xref:integration/appendix.adoc[]
 * xref:languages.adoc[]
 ** xref:languages/kotlin.adoc[]
@@ -439,4 +431,4 @@
 ** xref:languages/groovy.adoc[]
 ** xref:languages/dynamic.adoc[]
 * xref:appendix.adoc[]
-* {spring-framework-wiki}[Wiki]
+* https://github.com/spring-projects/spring-framework/wiki[Wiki]
@@ -8,7 +8,7 @@ within the core Spring Framework.
 [[appendix-spring-properties]]
 == Spring Properties

-{spring-framework-api}/core/SpringProperties.html[`SpringProperties`] is a static holder
+{api-spring-framework}/core/SpringProperties.html[`SpringProperties`] is a static holder
 for properties that control certain low-level aspects of the Spring Framework. Users can
 configure these properties via JVM system properties or programmatically via the
 `SpringProperties.setProperty(String key, String value)` method. The latter may be
@@ -25,7 +25,7 @@ The following table lists all currently supported Spring properties.
 | `spring.beaninfo.ignore`
 | Instructs Spring to use the `Introspector.IGNORE_ALL_BEANINFO` mode when calling the
 JavaBeans `Introspector`. See
-{spring-framework-api}++/beans/StandardBeanInfoFactory.html#IGNORE_BEANINFO_PROPERTY_NAME++[`CachedIntrospectionResults`]
+{api-spring-framework}++/beans/StandardBeanInfoFactory.html#IGNORE_BEANINFO_PROPERTY_NAME++[`CachedIntrospectionResults`]
 for details.

 | `spring.expression.compiler.mode`
@@ -36,9 +36,14 @@ xref:core/expressions/evaluation.adoc#expressions-compiler-configuration[Spring
 | Instructs Spring to ignore operating system environment variables if a Spring
 `Environment` property -- for example, a placeholder in a configuration String -- isn't
 resolvable otherwise. See
-{spring-framework-api}++/core/env/AbstractEnvironment.html#IGNORE_GETENV_PROPERTY_NAME++[`AbstractEnvironment`]
+{api-spring-framework}++/core/env/AbstractEnvironment.html#IGNORE_GETENV_PROPERTY_NAME++[`AbstractEnvironment`]
 for details.

+| `spring.index.ignore`
+| Instructs Spring to ignore the components index located in
+`META-INF/spring.components`. See xref:core/beans/classpath-scanning.adoc#beans-scanning-index[Generating an Index of Candidate Components]
+.
+
 | `spring.jdbc.getParameterType.ignore`
 | Instructs Spring to ignore `java.sql.ParameterMetaData.getParameterType` completely.
 See the note in xref:data-access/jdbc/advanced.adoc#jdbc-batch-list[Batch Operations with a List of Objects].
@@ -47,35 +52,27 @@ See the note in xref:data-access/jdbc/advanced.adoc#jdbc-batch-list[Batch Operat
 | Instructs Spring to ignore a default JNDI environment, as an optimization for scenarios
 where nothing is ever to be found for such JNDI fallback searches to begin with, avoiding
 the repeated JNDI lookup overhead. See
-{spring-framework-api}++/jndi/JndiLocatorDelegate.html#IGNORE_JNDI_PROPERTY_NAME++[`JndiLocatorDelegate`]
+{api-spring-framework}++/jndi/JndiLocatorDelegate.html#IGNORE_JNDI_PROPERTY_NAME++[`JndiLocatorDelegate`]
 for details.

 | `spring.objenesis.ignore`
 | Instructs Spring to ignore Objenesis, not even attempting to use it. See
-{spring-framework-api}++/objenesis/SpringObjenesis.html#IGNORE_OBJENESIS_PROPERTY_NAME++[`SpringObjenesis`]
+{api-spring-framework}++/objenesis/SpringObjenesis.html#IGNORE_OBJENESIS_PROPERTY_NAME++[`SpringObjenesis`]
 for details.

-| `spring.test.aot.processing.failOnError`
-| A boolean flag that controls whether errors encountered during AOT processing in the
-_Spring TestContext Framework_ should result in an exception that fails the overall process.
-See xref:testing/testcontext-framework/aot.adoc[Ahead of Time Support for Tests].
-
 | `spring.test.constructor.autowire.mode`
 | The default _test constructor autowire mode_ to use if `@TestConstructor` is not present
-on a test class. See xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-testconstructor[Changing the default test constructor autowire mode].
+on a test class. See xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-testconstructor[Changing the default test constructor autowire mode]
+.

 | `spring.test.context.cache.maxSize`
 | The maximum size of the context cache in the _Spring TestContext Framework_. See
 xref:testing/testcontext-framework/ctx-management/caching.adoc[Context Caching].

-| `spring.test.context.failure.threshold`
-| The failure threshold for errors encountered while attempting to load an `ApplicationContext`
-in the _Spring TestContext Framework_. See
-xref:testing/testcontext-framework/ctx-management/failure-threshold.adoc[Context Failure Threshold].
-
 | `spring.test.enclosing.configuration`
 | The default _enclosing configuration inheritance mode_ to use if
 `@NestedTestConfiguration` is not present on a test class. See
-xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-nestedtestconfiguration[Changing the default enclosing configuration inheritance mode].
+xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-nestedtestconfiguration[Changing the default enclosing configuration inheritance mode]
+.

 |===
@@ -0,0 +1,20 @@
+// Spring Portfolio
+:docs-site:                     https://docs.spring.io
+: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
+// spring-asciidoctor-backends Settings
+:chomp:                         default headers packages
+:fold:                          all
+// Spring Framework
+:docs-spring-framework:         {docs-site}/spring-framework/docs/{spring-version}
+:api-spring-framework:          {docs-spring-framework}/javadoc-api/org/springframework
+:docs-java:                     {docdir}/../../main/java/org/springframework/docs
+:docs-kotlin:                   {docdir}/../../main/kotlin/org/springframework/docs
+:docs-resources:                {docdir}/../../main/resources
+:spring-framework-main-code:    https://github.com/spring-projects/spring-framework/tree/main
+// Third-party Links
+:docs-graalvm:                  https://www.graalvm.org/22.3/reference-manual
+:gh-rsocket:                    https://github.com/rsocket
+:gh-rsocket-extensions:         {gh-rsocket}/rsocket/blob/master/Extensions
+:gh-rsocket-java:               {gh-rsocket}/rsocket-java
@@ -12,5 +12,5 @@ support for new custom advice types be added without changing the core framework
 The only constraint on a custom `Advice` type is that it must implement the
 `org.aopalliance.aop.Advice` marker interface.

-See the {spring-framework-api}/aop/framework/adapter/package-summary.html[`org.springframework.aop.framework.adapter`]
+See the {api-spring-framework}/aop/framework/adapter/package-summary.html[`org.springframework.aop.framework.adapter`]
 javadoc for further information.
@@ -119,7 +119,7 @@ The following listing shows an example configuration:

 Note that the target object (`businessObjectTarget` in the preceding example) must be a
 prototype. This lets the `PoolingTargetSource` implementation create new instances
-of the target to grow the pool as necessary. See the {spring-framework-api}/aop/target/AbstractPoolingTargetSource.html[javadoc of
+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.

@@ -52,7 +52,7 @@ Kotlin::
 ----
 ======

-See the {spring-framework-api}/aop/aspectj/annotation/AspectJProxyFactory.html[javadoc] for more information.
+See the {api-spring-framework}/aop/aspectj/annotation/AspectJProxyFactory.html[javadoc] for more information.



@@ -4,7 +4,7 @@

@AspectJ refers to a style of declaring aspects as regular Java classes annotated with
 annotations. The @AspectJ style was introduced by the
-{aspectj-site}[AspectJ project] as part of the AspectJ 5 release. Spring
+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.
@@ -176,7 +176,7 @@ Kotlin::
 		@AfterReturning(
 			pointcut = "execution(* com.xyz.dao.*.*(..))",
 			returning = "retVal")
-		fun doAccessCheck(retVal: Any?) {
+		fun doAccessCheck(retVal: Any) {
 			// ...
 		}
 	}
@@ -448,7 +448,7 @@ Kotlin::
 	class AroundExample {

 		@Around("execution(* com.xyz..service.*.*(..))")
-		fun doBasicProfiling(pjp: ProceedingJoinPoint): Any? {
+		fun doBasicProfiling(pjp: ProceedingJoinPoint): Any {
 			// start stopwatch
 			val retVal = pjp.proceed()
 			// stop stopwatch
@@ -482,7 +482,7 @@ The `JoinPoint` interface provides a number of useful methods:
 * `getSignature()`: Returns a description of the method that is being advised.
 * `toString()`: Prints a useful description of the method being advised.

-See the {aspectj-api}/org/aspectj/lang/JoinPoint.html[javadoc] for more detail.
+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
@@ -728,9 +728,14 @@ of determining parameter names, an exception will be thrown.
 `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
-  {spring-framework-api}/aop/aspectj/AspectJAdviceParameterNameDiscoverer.html[javadoc]
+  {api-spring-framework}/aop/aspectj/AspectJAdviceParameterNameDiscoverer.html[javadoc]
  for details on the algorithm used.

 [[aop-ataspectj-advice-params-names-explicit]]
@@ -888,7 +893,7 @@ Kotlin::
 			"com.xyz.CommonPointcuts.inDataAccessLayer() && " +
 			"args(accountHolderNamePattern)") // <1>
 	fun preProcessQueryPattern(pjp: ProceedingJoinPoint,
-							accountHolderNamePattern: String): Any? {
+							accountHolderNamePattern: String): Any {
 		val newPattern = preProcess(accountHolderNamePattern)
 		return pjp.proceed(arrayOf<Any>(newPattern))
 	}
@@ -85,7 +85,7 @@ Kotlin::
 		}

 		@Around("com.xyz.CommonPointcuts.businessService()") // <1>
-		fun doConcurrentOperation(pjp: ProceedingJoinPoint): Any? {
+		fun doConcurrentOperation(pjp: ProceedingJoinPoint): Any {
 			var numAttempts = 0
 			var lockFailureException: PessimisticLockingFailureException
 			do {
@@ -173,7 +173,7 @@ Kotlin::
 ----
 	@Around("execution(* com.xyz..service.*.*(..)) && " +
 			"@annotation(com.xyz.service.Idempotent)")
-	fun doConcurrentOperation(pjp: ProceedingJoinPoint): Any? {
+	fun doConcurrentOperation(pjp: ProceedingJoinPoint): Any {
 		// ...
 	}
 ----
@@ -6,8 +6,8 @@ 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
+aspects with alternate lifecycles. Spring supports AspectJ's `perthis` and `pertarget`
+instantiation models; `percflow`, `percflowbelow`, and `pertypewithin` are not currently
 supported.

 You can declare a `perthis` aspect by specifying a `perthis` clause in the `@Aspect`
@@ -36,9 +36,9 @@ Kotlin::

 The pointcut expression that forms the value of the `@Pointcut` annotation is a regular
 AspectJ pointcut expression. For a full discussion of AspectJ's pointcut language, see
-the {aspectj-docs-progguide}/index.html[AspectJ
+the https://www.eclipse.org/aspectj/doc/released/progguide/index.html[AspectJ
 Programming Guide] (and, for extensions, the
-{aspectj-docs}/adk15notebook/index.html[AspectJ 5
+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).

@@ -154,6 +154,7 @@ Java::
 ----
 	package com.xyz;

+	@Aspect
 	public class Pointcuts {

 		@Pointcut("execution(public * *(..))")
@@ -178,6 +179,7 @@ Kotlin::
 ----
 	package com.xyz

+	@Aspect
 	class Pointcuts {

 		@Pointcut("execution(public * *(..))")
@@ -209,9 +211,9 @@ pointcut matching.

 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):
+We recommend defining a dedicated aspect that captures commonly used _named pointcut_
+expressions for this purpose. Such an aspect typically resembles the following
+`CommonPointcuts` example (though what you name the aspect is up to you):

 [tabs]
 ======
@@ -221,8 +223,10 @@ Java::
 ----
 	package com.xyz;

+	import org.aspectj.lang.annotation.Aspect;
 	import org.aspectj.lang.annotation.Pointcut;

+	@Aspect
 	public class CommonPointcuts {

 		/**
@@ -283,8 +287,10 @@ Kotlin::
 ----
 	package com.xyz

+	import org.aspectj.lang.annotation.Aspect
 	import org.aspectj.lang.annotation.Pointcut

+	@Aspect
 	class CommonPointcuts {

 		/**
@@ -340,9 +346,9 @@ Kotlin::
 ----
 ======

-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
+You can refer to the pointcuts defined in such an aspect anywhere you need a pointcut
+expression by referencing the fully-qualified name of the `@Aspect` 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_:

@@ -392,7 +398,7 @@ method that takes no parameters, whereas `(..)` matches any number (zero or more
 The `({asterisk})` pattern matches a method that takes one parameter of any type.
 `(*,String)` matches a method that takes two parameters. The first can be of any type, while the
 second must be a `String`. Consult the
-{aspectj-docs-progguide}/semantics-pointcuts.html[Language
+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:
@@ -31,7 +31,7 @@ However, it would be even more confusing if Spring used its own terminology.
  the "advised object". Since Spring AOP is implemented by using runtime proxies, this
  object is always a proxied object.
 * AOP proxy: An object created by the AOP framework in order to implement the aspect
-  contracts (advice method executions and so on). In the Spring Framework, an AOP proxy
+  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
@@ -2,7 +2,7 @@
 = Further Resources
 :page-section-summary-toc: 1

-More information on AspectJ can be found on the {aspectj-site}[AspectJ website].
+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.
@@ -435,7 +435,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim",role="secondary"]
 ----
-	fun doBasicProfiling(pjp: ProceedingJoinPoint): Any? {
+	fun doBasicProfiling(pjp: ProceedingJoinPoint): Any {
 		// start stopwatch
 		val retVal = pjp.proceed()
 		// stop stopwatch
@@ -554,7 +554,7 @@ Kotlin::

 	class SimpleProfiler {

-		fun profile(call: ProceedingJoinPoint, name: String, age: Int): Any? {
+		fun profile(call: ProceedingJoinPoint, name: String, age: Int): Any {
 			val clock = StopWatch("Profiling for '$name' and '$age'")
 			try {
 				clock.start(call.toShortString())
@@ -890,7 +890,7 @@ Kotlin::
 			this.order = order
 		}

-		fun doConcurrentOperation(pjp: ProceedingJoinPoint): Any? {
+		fun doConcurrentOperation(pjp: ProceedingJoinPoint): Any {
 			var numAttempts = 0
 			var lockFailureException: PessimisticLockingFailureException
 			do {
@@ -136,7 +136,7 @@ using Spring in accordance with the properties of the annotation". In this conte
 "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
-{java-api}/java.base/java/io/Serializable.html[readResolve()]).
+https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html[readResolve()]).

 [NOTE]
 =====
@@ -168,13 +168,14 @@ Kotlin::

 You can find more information about the language semantics of the various pointcut
 types in AspectJ
-{aspectj-docs-progguide}/semantics-joinPoints.html[in this appendix] of the
-{aspectj-docs-progguide}/index.html[AspectJ Programming Guide].
+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
-{aspectj-docs-devguide}/antTasks.html[AspectJ Development
+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
@@ -398,7 +399,7 @@ The focus of this section is on configuring and using LTW in the specific contex
 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
-{aspectj-docs-devguide}/ltw.html[LTW section of the AspectJ
+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
@@ -420,7 +421,7 @@ who typically are in charge of the deployment configuration, such as the launch
 Now that the sales pitch is over, let us first walk through a quick example of AspectJ
 LTW that uses Spring, followed by detailed specifics about elements introduced in the
 example. For a complete example, see the
-{spring-github-org}/spring-petclinic[Petclinic sample application].
+https://github.com/spring-projects/spring-petclinic[Petclinic sample application].


 [[aop-aj-ltw-first-example]]
@@ -492,7 +493,7 @@ Kotlin::
 	class ProfilingAspect {

 		@Around("methodsToBeProfiled()")
-		fun profile(pjp: ProceedingJoinPoint): Any? {
+		fun profile(pjp: ProceedingJoinPoint): Any {
 			val sw = StopWatch(javaClass.simpleName)
 			try {
 				sw.start(pjp.getSignature().getName())
@@ -620,7 +621,7 @@ java -javaagent:C:/projects/xyz/lib/spring-instrument.jar com.xyz.Main
 ----

 The `-javaagent` is a flag for specifying and enabling
-{java-api}/java.instrument/java/lang/instrument/package-summary.html[agents
+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
@@ -720,7 +721,7 @@ The AspectJ LTW infrastructure is configured by using one or more `META-INF/aop.
 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
-{aspectj-docs-devguide}/ltw-configuration.html[AspectJ reference
+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.


@@ -827,6 +828,13 @@ The following table summarizes various `LoadTimeWeaver` implementations:
 | Running in Red Hat's https://www.jboss.org/jbossas/[JBoss AS] or https://www.wildfly.org/[WildFly]
 | `JBossLoadTimeWeaver`

+| Running in IBM's https://www-01.ibm.com/software/webservers/appserv/was/[WebSphere]
+| `WebSphereLoadTimeWeaver`
+
+| Running in Oracle's
+  https://www.oracle.com/technetwork/middleware/weblogic/overview/index-085209.html[WebLogic]
+| `WebLogicLoadTimeWeaver`
+
 | JVM started with Spring `InstrumentationSavingAgent`
  (`java -javaagent:path/to/spring-instrument.jar`)
 | `InstrumentationLoadTimeWeaver`
@@ -941,11 +949,11 @@ when you use Spring's LTW support in environments such as application servers an
 containers.

 [[aop-aj-ltw-environments-tomcat-jboss-etc]]
-==== Tomcat, JBoss, WildFly
+==== Tomcat, JBoss, WebSphere, WebLogic

-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.
+Tomcat, JBoss/WildFly, IBM WebSphere Application Server and Oracle WebLogic Server all
+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`.
@@ -17,7 +17,7 @@ Applying such optimizations early implies the following restrictions:
 * The beans defined in your application cannot change at runtime, meaning:
 ** `@Profile`, in particular profile-specific configuration needs to be chosen at build time.
 ** `Environment` properties that impact the presence of a bean (`@Conditional`) are only considered at build time.
-* Bean definitions with instance suppliers (lambdas or method references) cannot be transformed ahead-of-time (see related {spring-framework-issues}/29555[spring-framework#29555] issue).
+* Bean definitions with instance suppliers (lambdas or method references) cannot be transformed ahead-of-time (see related https://github.com/spring-projects/spring-framework/issues/29555[spring-framework#29555] issue).
 * Make sure that the bean type is as precise as possible.

 TIP: See also the xref:core/aot.adoc#aot.bestpractices[] section.
@@ -27,7 +27,7 @@ A Spring AOT processed application typically generates:

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

 NOTE: At the moment, AOT is focused on allowing Spring applications to be deployed as native images using GraalVM.
 We intend to support more JVM-based use cases in future generations.
@@ -35,7 +35,7 @@ We intend to support more JVM-based use cases in future generations.
 [[aot.basics]]
 == AOT engine overview

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

 * Refresh an `ApplicationContext` for AOT processing. Contrary to a traditional refresh, this version only creates bean definitions, not bean instances.
 * Invoke the available `BeanFactoryInitializationAotProcessor` implementations and apply their contributions against the `GenerationContext`.
@@ -81,7 +81,7 @@ Once this part completes, the `BeanFactory` contains the bean definitions that a
 [[aot.bean-factory-initialization-contributions]]
 == Bean Factory Initialization AOT Contributions

-Components that want to participate in this step can implement the {spring-framework-api}/beans/factory/aot/BeanFactoryInitializationAotProcessor.html[`BeanFactoryInitializationAotProcessor`] interface.
+Components that want to participate in this step can implement the {api-spring-framework}/beans/factory/aot/BeanFactoryInitializationAotProcessor.html[`BeanFactoryInitializationAotProcessor`] interface.
 Each implementation can return an AOT contribution, based on the state of the bean factory.

 An AOT contribution is a component that contributes generated code that reproduces a particular behavior.
@@ -156,7 +156,6 @@ Java::
 	/**
 	 * Bean definitions for {@link DataSourceConfiguration}
 	 */
-	@Generated
 	public class DataSourceConfiguration__BeanDefinitions {
 		/**
 		 * Get the bean definition for 'dataSourceConfiguration'
@@ -191,9 +190,6 @@ Java::

 NOTE: The exact code generated may differ depending on the exact nature of your bean definitions.

-TIP: Each generated class is annotated with `org.springframework.aot.generate.Generated` to
-identify them if they need to be excluded, for instance by static analysis tools.
-
 The generated code above creates bean definitions equivalent to the `@Configuration` class, but in a direct way and without the use of reflection if at all possible.
 There is a bean definition for `dataSourceConfiguration` and one for `dataSourceBean`.
 When a `datasource` instance is required, a `BeanInstanceSupplier` is called.
@@ -260,13 +256,6 @@ Java::

 If you are registering bean definitions programmatically, consider using `RootBeanBefinition` as it allows to specify a `ResolvableType` that handles generics.

-[[aot.bestpractices.constructors]]
-=== Avoid Multiple Constructors
-The container is able to choose the most appropriate constructor to use based on several candidates.
-However, this is not a best practice and flagging the preferred constructor with `@Autowired` if necessary is preferred.
-
-In case you are working on a code base that you can't modify, you can set the {spring-framework-api}/beans/factory/support/AbstractBeanDefinition.html#PREFERRED_CONSTRUCTORS_ATTRIBUTE[`preferredConstructors` attribute] on the related bean definition to indicate which constructor should be used.
-
 [[aot.bestpractices.factory-bean]]
 === FactoryBean

@@ -329,51 +318,6 @@ Java::
 ----
 ======

-[[aot.bestpractices.jpa]]
-=== JPA
-
-The JPA persistence unit has to be known upfront for certain optimizations to apply. Consider the following basic example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	@Bean
-	LocalContainerEntityManagerFactoryBean customDBEntityManagerFactory(DataSource dataSource) {
-		LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
-		factoryBean.setDataSource(dataSource);
-		factoryBean.setPackagesToScan("com.example.app");
-		return factoryBean;
-	}
----
-======
-
-To make sure the scanning occurs ahead of time, a `PersistenceManagedTypes` bean must be declared and used by the
-factory bean definition, as shown by the following example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	@Bean
-	PersistenceManagedTypes persistenceManagedTypes(ResourceLoader resourceLoader) {
-		return new PersistenceManagedTypesScanner(resourceLoader)
-				.scan("com.example.app");
-	}
-
-	@Bean
-	LocalContainerEntityManagerFactoryBean customDBEntityManagerFactory(DataSource dataSource, PersistenceManagedTypes managedTypes) {
-		LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
-		factoryBean.setDataSource(dataSource);
-		factoryBean.setManagedTypes(managedTypes);
-		return factoryBean;
-	}
----
-======

 [[aot.hints]]
 == Runtime Hints
@@ -383,7 +327,7 @@ For instance, GraalVM needs to know ahead of time if a component uses reflection
 Similarly, classpath resources are not shipped in a native image unless specified explicitly.
 Consequently, if the application needs to load a resource, it must be referenced from the corresponding GraalVM native image configuration file.

-The {spring-framework-api}/aot/hint/RuntimeHints.html[`RuntimeHints`] API collects the need for reflection, resource loading, serialization, and JDK proxies at runtime.
+The {api-spring-framework}/aot/hint/RuntimeHints.html[`RuntimeHints`] API collects the need for reflection, resource loading, serialization, and JDK proxies at runtime.
 The following example makes sure that `config/app.properties` can be loaded from the classpath at runtime within a native image:

 [tabs]
@@ -421,7 +365,7 @@ It is also possible to register an implementation statically by adding an entry
 [[aot.hints.reflective]]
 === `@Reflective`

-{spring-framework-api}/aot/hint/annotation/Reflective.html[`@Reflective`] provides an idiomatic way to flag the need for reflection on an annotated element.
+{api-spring-framework}/aot/hint/annotation/Reflective.html[`@Reflective`] provides an idiomatic way to flag the need for reflection on an annotated element.
 For instance, `@EventListener` is meta-annotated with `@Reflective` since the underlying implementation invokes the annotated method using reflection.

 By default, only Spring beans are considered and an invocation hint is registered for the annotated element.
@@ -435,7 +379,7 @@ If components other than Spring beans need to be processed, a `BeanFactoryInitia
 [[aot.hints.register-reflection-for-binding]]
 === `@RegisterReflectionForBinding`

-{spring-framework-api}/aot/hint/annotation/RegisterReflectionForBinding.html[`@RegisterReflectionForBinding`] is a specialization of `@Reflective` that registers the need for serializing arbitrary types.
+{api-spring-framework}/aot/hint/annotation/RegisterReflectionForBinding.html[`@RegisterReflectionForBinding`] is a specialization of `@Reflective` that registers the need for serializing arbitrary types.
 A typical use case is the use of DTOs that the container cannot infer, such as using a web client within a method body.

 `@RegisterReflectionForBinding` can be applied to any Spring bean at the class level, but it can also be applied directly to a method, field, or constructor to better indicate where the hints are actually required.
@@ -471,7 +415,7 @@ include-code::./SpellCheckServiceTests[tag=hintspredicates]
 With `RuntimeHintsPredicates`, we can check for reflection, resource, serialization, or proxy generation hints.
 This approach works well for unit tests but implies that the runtime behavior of a component is well known.

-You can learn more about the global runtime behavior of an application by running its test suite (or the app itself) with the {graalvm-docs}/native-image/metadata/AutomaticMetadataCollection/[GraalVM tracing agent].
+You can learn more about the global runtime behavior of an application by running its test suite (or the app itself) with the {docs-graalvm}/native-image/metadata/AutomaticMetadataCollection/[GraalVM tracing agent].
 This agent will record all relevant calls requiring GraalVM hints at runtime and write them out as JSON configuration files.

 For more targeted discovery and testing, Spring Framework ships a dedicated module with core AOT testing utilities, `"org.springframework:spring-core-test"`.
@@ -503,4 +447,4 @@ io.spring.runtimehintstesting.SampleReflectionRuntimeHintsTests#lambda$shouldReg

 There are various ways to configure this Java agent in your build, so please refer to the documentation of your build tool and test execution plugin.
 The agent itself can be configured to instrument specific packages (by default, only `org.springframework` is instrumented).
-You'll find more details in the {spring-framework-code}/buildSrc/README.md[Spring Framework `buildSrc` README] file.
+You'll find more details in the {spring-framework-main-code}/buildSrc/README.md[Spring Framework `buildSrc` README] file.
@@ -765,7 +765,7 @@ want to add an additional attribute to the existing bean definition element.

 By way of another example, suppose that you define a bean definition for a
 service object that (unknown to it) accesses a clustered
-{JSR}107[JCache], and you want to ensure that the
+https://jcp.org/en/jsr/detail?id=107[JCache], and you want to ensure that the
 named JCache instance is eagerly started within the surrounding cluster.
 The following listing shows such a definition:

@@ -66,13 +66,13 @@ developer's intent ("`inject this constant value`"), and it reads better:
 [[xsd-schemas-util-frfb]]
 ==== Setting a Bean Property or Constructor Argument from a Field Value

-{spring-framework-api}/beans/factory/config/FieldRetrievingFactoryBean.html[`FieldRetrievingFactoryBean`]
+{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
-{spring-framework-api}/beans/factory/config/FieldRetrievingFactoryBean.html#setStaticField(java.lang.String)[`staticField`]
+{api-spring-framework}/beans/factory/config/FieldRetrievingFactoryBean.html#setStaticField(java.lang.String)[`staticField`]
 property:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -109,7 +109,7 @@ to be specified for the bean reference, as the following example shows:

 You can also access a non-static (instance) field of another bean, as
 described in the API documentation for the
-{spring-framework-api}/beans/factory/config/FieldRetrievingFactoryBean.html[`FieldRetrievingFactoryBean`]
+{api-spring-framework}/beans/factory/config/FieldRetrievingFactoryBean.html[`FieldRetrievingFactoryBean`]
 class.

 Injecting enumeration values into beans as either property or constructor arguments is
@@ -565,17 +565,6 @@ is a convenience mechanism that sets up a xref:core/beans/factory-extension.adoc
 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/>`
@@ -17,7 +17,7 @@ No matter the choice, Spring can accommodate both styles and even mix them toget
 It is worth pointing out that through its xref:core/beans/java.adoc[JavaConfig] option, Spring lets
 annotations be used in a non-invasive way, without touching the target components'
 source code and that, in terms of tooling, all configuration styles are supported by
-{spring-site-tools}[Spring Tools] for Eclipse, Visual Studio Code, and Theia.
+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
@@ -62,11 +62,11 @@ configuration (notice the inclusion of the `context` namespace):

 The `<context:annotation-config/>` element implicitly registers the following post-processors:

-* {spring-framework-api}/context/annotation/ConfigurationClassPostProcessor.html[`ConfigurationClassPostProcessor`]
-* {spring-framework-api}/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.html[`AutowiredAnnotationBeanPostProcessor`]
-* {spring-framework-api}/context/annotation/CommonAnnotationBeanPostProcessor.html[`CommonAnnotationBeanPostProcessor`]
-* {spring-framework-api}/orm/jpa/support/PersistenceAnnotationBeanPostProcessor.html[`PersistenceAnnotationBeanPostProcessor`]
-* {spring-framework-api}/context/event/EventListenerMethodProcessor.html[`EventListenerMethodProcessor`]
+* {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]
 ====
@@ -364,6 +364,8 @@ ignored if it cannot be autowired. This allows properties to be assigned default
 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
@@ -1,7 +1,7 @@
 [[beans-custom-autowire-configurer]]
 = Using `CustomAutowireConfigurer`

-{spring-framework-api}/beans/factory/annotation/CustomAutowireConfigurer.html[`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`:
@@ -84,7 +84,7 @@ Kotlin::
 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
-{spring-framework-api}/jndi/support/SimpleJndiBeanFactory.html[`SimpleJndiBeanFactory`]
+{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.

@@ -12,8 +12,8 @@ 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
-{spring-framework-api}/context/support/ClassPathXmlApplicationContext.html[`ClassPathXmlApplicationContext`]
-or {spring-framework-api}/context/support/FileSystemXmlApplicationContext.html[`FileSystemXmlApplicationContext`].
+{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
@@ -22,11 +22,10 @@ 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 {spring-site-tools}[Spring Tools for Eclipse] (an Eclipse-powered
-development environment), you can easily create this boilerplate configuration with a
-few mouse clicks or keystrokes.
+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
@@ -61,10 +60,10 @@ For information about using other forms of metadata with the Spring container, s
  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
-  {spring-framework-api}/context/annotation/Configuration.html[`@Configuration`],
-  {spring-framework-api}/context/annotation/Bean.html[`@Bean`],
-  {spring-framework-api}/context/annotation/Import.html[`@Import`],
-  and {spring-framework-api}/context/annotation/DependsOn.html[`@DependsOn`] annotations.
+  {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
@@ -140,11 +139,9 @@ Kotlin::
 [NOTE]
 ====
 After you learn about Spring's IoC container, you may want to know more about Spring's
-`Resource` abstraction (as described in
-xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources])
-which provides a convenient mechanism for reading an InputStream from locations defined
-in a URI syntax. In particular, `Resource` paths are used to construct applications contexts,
-as described in xref:core/resources.adoc#resources-app-ctx[Application Contexts and Resource Paths].
+`Resource` abstraction (as described in xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources]), which provides a convenient
+mechanism for reading an InputStream from locations defined in a URI syntax. In particular,
+`Resource` paths are used to construct applications contexts, as described in xref:core/resources.adoc#resources-app-ctx[Application Contexts and Resource Paths].
 ====

 The following example shows the service layer objects `(services.xml)` configuration file:
@@ -211,9 +208,9 @@ 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:
+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"]
 ----
@@ -27,7 +27,7 @@ use these features.
 == `@Component` and Further Stereotype Annotations

 The `@Repository` annotation is a marker for any class that fulfills the role or
-_stereotype_ of a repository (also known as Data Access Object or DAO). Among the uses
+stereotype of a repository (also known as Data Access Object or DAO). Among the uses
 of this marker is the automatic translation of exceptions, as described in
 xref:data-access/orm/general.adoc#orm-exception-translation[Exception Translation].

@@ -39,7 +39,7 @@ layers, respectively). Therefore, you can annotate your component classes with
 `@Component`, but, by annotating them with `@Repository`, `@Service`, or `@Controller`
 instead, your classes are more properly suited for processing by tools or associating
 with aspects. For example, these stereotype annotations make ideal targets for
-pointcuts. `@Repository`, `@Service`, and `@Controller` may also
+pointcuts. `@Repository`, `@Service`, and `@Controller` can also
 carry additional semantics in future releases of the Spring Framework. Thus, if you are
 choosing between using `@Component` or `@Service` for your service layer, `@Service` is
 clearly the better choice. Similarly, as stated earlier, `@Repository` is already
@@ -191,7 +191,7 @@ Kotlin::
 ======

 For further details, see the
-{spring-framework-wiki}/Spring-Annotation-Programming-Model[Spring Annotation Programming Model]
+https://github.com/spring-projects/spring-framework/wiki/Spring-Annotation-Programming-Model[Spring Annotation Programming Model]
 wiki page.


@@ -315,7 +315,7 @@ entries in the classpath. When you build JARs with Ant, make sure that you do no
 activate the files-only switch of the JAR task. Also, classpath directories may not be
 exposed based on security policies in some environments -- for example, standalone apps on
 JDK 1.7.0_45 and higher (which requires 'Trusted-Library' setup in your manifests -- see
-{stackoverflow-questions}/19394570/java-jre-7u45-breaks-classloader-getresources).
+https://stackoverflow.com/questions/19394570/java-jre-7u45-breaks-classloader-getresources).

 On JDK 9's module path (Jigsaw), Spring's classpath scanning generally works as expected.
 However, make sure that your component classes are exported in your `module-info`
@@ -664,36 +664,15 @@ analogous to how the container selects between multiple `@Autowired` constructor
 == Naming Autodetected Components

 When a component is autodetected as part of the scanning process, its bean name is
-generated by the `BeanNameGenerator` strategy known to that scanner.
+generated by the `BeanNameGenerator` strategy known to that scanner. By default, any
+Spring stereotype annotation (`@Component`, `@Repository`, `@Service`, and
+`@Controller`) that contains a name `value` thereby provides that name to the
+corresponding bean definition.

-By default, the `AnnotationBeanNameGenerator` is used. For Spring
-xref:core/beans/classpath-scanning.adoc#beans-stereotype-annotations[stereotype annotations],
-if you supply a name via the annotation's `value` attribute that name will be used as
-the name in the corresponding bean definition. This convention also applies when the
-following JSR-250 and JSR-330 annotations are used instead of Spring stereotype
-annotations: `@jakarta.annotation.ManagedBean`, `@javax.annotation.ManagedBean`,
-`@jakarta.inject.Named`, and `@javax.inject.Named`.
-
-As of Spring Framework 6.1, the name of the annotation attribute that is used to specify
-the bean name is no longer required to be `value`. Custom stereotype annotations can
-declare an attribute with a different name (such as `name`) and annotate that attribute
-with `@AliasFor(annotation = Component.class, attribute = "value")`. See the source code
-declaration of `ControllerAdvice#name()` for a concrete example.
-
-[WARNING]
-====
-As of Spring Framework 6.1, support for convention-based stereotype names is deprecated
-and will be removed in a future version of the framework. Consequently, custom stereotype
-annotations must use `@AliasFor` to declare an explicit alias for the `value` attribute
-in `@Component`. See the source code declaration of `Repository#value()` and
-`ControllerAdvice#name()` for concrete examples.
-====
-
-If an explicit bean name cannot be derived from such an annotation or for any other
-detected component (such as those discovered by custom filters), the default bean name
-generator returns the uncapitalized non-qualified class name. For example, if the
-following component classes were detected, the names would be `myMovieLister` and
-`movieFinderImpl`.
+If such an annotation contains no name `value` or for any other detected component
+(such as those discovered by custom filters), the default bean name generator returns
+the uncapitalized non-qualified class name. For example, if the following component
+classes were detected, the names would be `myMovieLister` and `movieFinderImpl`:

 [tabs]
 ======
@@ -743,7 +722,7 @@ Kotlin::

 If you do not want to rely on the default bean-naming strategy, you can provide a custom
 bean-naming strategy. First, implement the
-{spring-framework-api}/beans/factory/support/BeanNameGenerator.html[`BeanNameGenerator`]
+{api-spring-framework}/beans/factory/support/BeanNameGenerator.html[`BeanNameGenerator`]
 interface, and be sure to include a default no-arg constructor. Then, provide the fully
 qualified class name when configuring the scanner, as the following example annotation
 and bean definition show.
@@ -840,7 +819,7 @@ possibly also declaring a custom scoped-proxy mode.

 NOTE: To provide a custom strategy for scope resolution rather than relying on the
 annotation-based approach, you can implement the
-{spring-framework-api}/context/annotation/ScopeMetadataResolver.html[`ScopeMetadataResolver`]
+{api-spring-framework}/context/annotation/ScopeMetadataResolver.html[`ScopeMetadataResolver`]
 interface. Be sure to include a default no-arg constructor. Then you can provide the
 fully qualified class name when configuring the scanner, as the following example of both
 an annotation and a bean definition shows:
@@ -1010,4 +989,68 @@ metadata is provided per-instance rather than per-class.



+[[beans-scanning-index]]
+== Generating an Index of Candidate Components
+
+While classpath scanning is very fast, it is possible to improve the startup performance
+of large applications by creating a static list of candidates at compilation time. In this
+mode, all modules that are targets of component scanning must use this mechanism.
+
+NOTE: Your existing `@ComponentScan` or `<context:component-scan/>` directives must remain
+unchanged to request the context to scan candidates in certain packages. When the
+`ApplicationContext` detects such an index, it automatically uses it rather than scanning
+the classpath.
+
+To generate the index, add an additional dependency to each module that contains
+components that are targets for component scan directives. The following example shows
+how to do so with Maven:
+
+[source,xml,indent=0,subs="verbatim,quotes,attributes"]
+----
+	<dependencies>
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-context-indexer</artifactId>
+			<version>{spring-version}</version>
+			<optional>true</optional>
+		</dependency>
+	</dependencies>
+----
+
+With Gradle 4.5 and earlier, the dependency should be declared in the `compileOnly`
+configuration, as shown in the following example:
+
+[source,groovy,indent=0,subs="verbatim,quotes,attributes"]
+----
+	dependencies {
+		compileOnly "org.springframework:spring-context-indexer:{spring-version}"
+	}
+----
+
+With Gradle 4.6 and later, the dependency should be declared in the `annotationProcessor`
+configuration, as shown in the following example:
+
+[source,groovy,indent=0,subs="verbatim,quotes,attributes"]
+----
+	dependencies {
+		annotationProcessor "org.springframework:spring-context-indexer:{spring-version}"
+	}
+----
+
+The `spring-context-indexer` artifact generates a `META-INF/spring.components` file that
+is included in the jar file.
+
+NOTE: When working with this mode in your IDE, the `spring-context-indexer` must be
+registered as an annotation processor to make sure the index is up-to-date when
+candidate components are updated.
+
+TIP: The index is enabled automatically when a `META-INF/spring.components` file is found
+on the classpath. If an index is partially available for some libraries (or use cases)
+but could not be built for the whole application, you can fall back to a regular classpath
+arrangement (as though no index were present at all) by setting `spring.index.ignore` to
+`true`, either as a JVM system property or via the
+xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
+
+
+

@@ -4,7 +4,7 @@
 As discussed in the xref:web/webmvc-view/mvc-xslt.adoc#mvc-view-xslt-beandefs[chapter introduction], the `org.springframework.beans.factory`
 package provides basic functionality for managing and manipulating beans, including in a
 programmatic way. The `org.springframework.context` package adds the
-{spring-framework-api}/context/ApplicationContext.html[`ApplicationContext`]
+{api-spring-framework}/context/ApplicationContext.html[`ApplicationContext`]
 interface, which extends the `BeanFactory` interface, in addition to extending other
 interfaces to provide additional functionality in a more application
 framework-oriented style. Many people use the `ApplicationContext` in a completely
@@ -269,7 +269,7 @@ file format but is more flexible than the standard JDK based
 `ResourceBundleMessageSource` implementation. In particular, it allows for reading
 files from any Spring resource location (not only from the classpath) and supports hot
 reloading of bundle property files (while efficiently caching them in between).
-See the {spring-framework-api}/context/support/ReloadableResourceBundleMessageSource.html[`ReloadableResourceBundleMessageSource`]
+See the {api-spring-framework}/context/support/ReloadableResourceBundleMessageSource.html[`ReloadableResourceBundleMessageSource`]
 javadoc for details.


@@ -478,21 +478,19 @@ Kotlin::
 ----
 ======

-Notice that `ApplicationListener` is generically parameterized with the type of your custom event (`BlockedListEvent` in the preceding example).
-This means that the `onApplicationEvent()` method can remain type-safe, avoiding any need for downcasting.
-You can register as many event listeners as you wish, but note that, by default, event listeners receive events synchronously.
-This means that the `publishEvent()` method blocks until all listeners have finished processing the event.
-One advantage of this synchronous and single-threaded approach is that, when a listener receives an event,
-it operates inside the transaction context of the publisher if a transaction context is available.
-If another strategy for event publication becomes necessary, e.g. asynchronous event processing by default,
-see the javadoc for Spring's {spring-framework-api}/context/event/ApplicationEventMulticaster.html[`ApplicationEventMulticaster`] interface
-and {spring-framework-api}/context/event/SimpleApplicationEventMulticaster.html[`SimpleApplicationEventMulticaster`] implementation
-for configuration options which can be applied to a custom "applicationEventMulticaster" bean definition.
-In these cases, ThreadLocals and logging context are not propagated for the event processing.
-See xref:integration/observability.adoc#observability.application-events[the `@EventListener` Observability section]
-for more information on Observability concerns.
-
-
+Notice that `ApplicationListener` is generically parameterized with the type of your
+custom event (`BlockedListEvent` in the preceding example). This means that the
+`onApplicationEvent()` method can remain type-safe, avoiding any need for downcasting.
+You can register as many event listeners as you wish, but note that, by default, event
+listeners receive events synchronously. This means that the `publishEvent()` method
+blocks until all listeners have finished processing the event. One advantage of this
+synchronous and single-threaded approach is that, when a listener receives an event, it
+operates inside the transaction context of the publisher if a transaction context is
+available. If another strategy for event publication becomes necessary, see the javadoc
+for Spring's
+{api-spring-framework}/context/event/ApplicationEventMulticaster.html[`ApplicationEventMulticaster`] interface
+and {api-spring-framework}/context/event/SimpleApplicationEventMulticaster.html[`SimpleApplicationEventMulticaster`]
+implementation for configuration options.

 The following example shows the bean definitions used to register and configure each of
 the classes above:
@@ -512,12 +510,6 @@ the classes above:
 	<bean id="blockedListNotifier" class="example.BlockedListNotifier">
 		<property name="notificationAddress" value="blockedlist@example.org"/>
 	</bean>
-
-    <!-- optional: a custom ApplicationEventMulticaster definition -->
-	<bean id="applicationEventMulticaster" class="org.springframework.context.event.SimpleApplicationEventMulticaster">
-		<property name="taskExecutor" ref="..."/>
-		<property name="errorHandler" ref="..."/>
-	</bean>
 ----

 Putting it all together, when the `sendEmail()` method of the `emailService` bean is
@@ -529,7 +521,7 @@ notify appropriate parties.
 NOTE: Spring's eventing mechanism is designed for simple communication between Spring beans
 within the same application context. However, for more sophisticated enterprise
 integration needs, the separately maintained
-{spring-site-projects}/spring-integration/[Spring Integration] project provides
+https://projects.spring.io/spring-integration/[Spring Integration] project provides
 complete support for building lightweight,
 https://www.enterpriseintegrationpatterns.com[pattern-oriented], event-driven
 architectures that build upon the well-known Spring programming model.
@@ -742,15 +734,12 @@ Be aware of the following limitations when using asynchronous events:

 * If an asynchronous event listener throws an `Exception`, it is not propagated to the
  caller. See
-  {spring-framework-api}/aop/interceptor/AsyncUncaughtExceptionHandler.html[`AsyncUncaughtExceptionHandler`]
+  {api-spring-framework}/aop/interceptor/AsyncUncaughtExceptionHandler.html[`AsyncUncaughtExceptionHandler`]
  for more details.
 * Asynchronous event listener methods cannot publish a subsequent event by returning a
  value. If you need to publish another event as the result of the processing, inject an
-  {spring-framework-api}/context/ApplicationEventPublisher.html[`ApplicationEventPublisher`]
+  {api-spring-framework}/context/ApplicationEventPublisher.html[`ApplicationEventPublisher`]
  to publish the event manually.
-* ThreadLocals and logging context are not propagated by default for the event processing.
-  See xref:integration/observability.adoc#observability.application-events[the `@EventListener` Observability section]
-  for more information on Observability concerns.


 [[context-functionality-events-order]]
@@ -860,23 +849,6 @@ Kotlin::
 TIP: This works not only for `ApplicationEvent` but any arbitrary object that you send as
 an event.

-Finally, as with classic `ApplicationListener` implementations, the actual multicasting
-happens via a context-wide `ApplicationEventMulticaster` at runtime. By default, this is a
-`SimpleApplicationEventMulticaster` with synchronous event publication in the caller thread.
-This can be replaced/customized through an "applicationEventMulticaster" bean definition,
-e.g. for processing all events asynchronously and/or for handling listener exceptions:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	@Bean
-	ApplicationEventMulticaster applicationEventMulticaster() {
-		SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
-		multicaster.setTaskExecutor(...);
-		multicaster.setErrorHandler(...);
-		return multicaster;
-	}
----
-


 [[context-functionality-resources]]
@@ -938,7 +910,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
 	// create a startup step and start recording
-	StartupStep scanPackages = getApplicationStartup().start("spring.context.base-packages.scan");
+	StartupStep scanPackages = this.getApplicationStartup().start("spring.context.base-packages.scan");
 	// add tagging information to the current step
 	scanPackages.tag("packages", () -> Arrays.toString(basePackages));
 	// perform the actual phase we're instrumenting
@@ -952,7 +924,7 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
 	// create a startup step and start recording
-	val scanPackages = getApplicationStartup().start("spring.context.base-packages.scan")
+	val scanPackages = this.getApplicationStartup().start("spring.context.base-packages.scan")
 	// add tagging information to the current step
 	scanPackages.tag("packages", () -> Arrays.toString(basePackages))
 	// perform the actual phase we're instrumenting
@@ -1040,7 +1012,7 @@ and JMX support facilities. Application components can also interact with the ap
 server's JCA `WorkManager` through Spring's `TaskExecutor` abstraction.

 See the javadoc of the
-{spring-framework-api}/jca/context/SpringContextResourceAdapter.html[`SpringContextResourceAdapter`]
+{api-spring-framework}/jca/context/SpringContextResourceAdapter.html[`SpringContextResourceAdapter`]
 class for the configuration details involved in RAR deployment.

 For a simple deployment of a Spring ApplicationContext as a Jakarta EE RAR file:
@@ -1050,7 +1022,7 @@ all application classes into a RAR file (which is a standard JAR file with a dif
 file extension).
 . Add all required library JARs into the root of the RAR archive.
 . Add a
-`META-INF/ra.xml` deployment descriptor (as shown in the {spring-framework-api}/jca/context/SpringContextResourceAdapter.html[javadoc for `SpringContextResourceAdapter`])
+`META-INF/ra.xml` deployment descriptor (as shown in the {api-spring-framework}/jca/context/SpringContextResourceAdapter.html[javadoc for `SpringContextResourceAdapter`])
 and the corresponding Spring XML bean definition file(s) (typically
 `META-INF/applicationContext.xml`).
 . Drop the resulting RAR file into your
@@ -44,7 +44,7 @@ weaver instance. This is particularly useful in combination with
 xref:data-access/orm/jpa.adoc[Spring's JPA support] where load-time weaving may be
 necessary for JPA class transformation.
 Consult the
-{spring-framework-api}/orm/jpa/LocalContainerEntityManagerFactoryBean.html[`LocalContainerEntityManagerFactoryBean`]
+{api-spring-framework}/orm/jpa/LocalContainerEntityManagerFactoryBean.html[`LocalContainerEntityManagerFactoryBean`]
 javadoc for more detail. For more on AspectJ load-time weaving, see xref:core/aop/using-aspectj.adoc#aop-aj-ltw[Load-time Weaving with AspectJ in the Spring Framework].


@@ -309,7 +309,7 @@ how to configure such a bean:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
-	<!-- the factory bean, which contains a method called createClientServiceInstance() -->
+	<!-- the factory bean, which contains a method called createInstance() -->
 	<bean id="serviceLocator" class="examples.DefaultServiceLocator">
 		<!-- inject any dependencies required by this locator bean -->
 	</bean>
@@ -99,7 +99,7 @@ container, lets you handle this use case cleanly.

 ****
 You can read more about the motivation for Method Injection in
-{spring-site-blog}/2004/08/06/method-injection/[this blog entry].
+https://spring.io/blog/2004/08/06/method-injection/[this blog entry].
 ****


@@ -51,7 +51,7 @@ XML configuration:

 The preceding XML is more succinct. However, typos are discovered at runtime rather than
 design time, unless you use an IDE (such as https://www.jetbrains.com/idea/[IntelliJ
-IDEA] or the {spring-site-tools}[Spring Tools for Eclipse])
+IDEA] or the https://spring.io/tools[Spring Tools for Eclipse])
 that supports automatic property completion when you create bean definitions. Such IDE
 assistance is highly recommended.

@@ -1,7 +1,7 @@
 [[beans-environment]]
 = Environment Abstraction

-The {spring-framework-api}/core/env/Environment.html[`Environment`] interface
+The {api-spring-framework}/core/env/Environment.html[`Environment`] interface
 is an abstraction integrated in the container that models two key
 aspects of the application environment: xref:core/beans/environment.adoc#beans-definition-profiles[profiles]
 and xref:core/beans/environment.adoc#beans-property-source-abstraction[properties].
@@ -118,7 +118,7 @@ situation B. We start by updating our configuration to reflect this need.
 [[beans-definition-profiles-java]]
 === Using `@Profile`

-The {spring-framework-api}/context/annotation/Profile.html[`@Profile`]
+The {api-spring-framework}/context/annotation/Profile.html[`@Profile`]
 annotation lets you indicate that a component is eligible for registration
 when one or more specified profiles are active. Using our preceding example, we
 can rewrite the `dataSource` configuration as follows:
@@ -516,8 +516,8 @@ as the following example shows:
 [[beans-definition-profiles-default]]
 === Default Profile

-The default profile represents the profile that is enabled if no profile is active. Consider
-the following example:
+The default profile represents the profile that is enabled by default. Consider the
+following example:

 [tabs]
 ======
@@ -558,13 +558,12 @@ Kotlin::
 ----
 ======

-If xref:#beans-definition-profiles-enable[no profile is active], the `dataSource` is
-created. You can see this as a way to provide a default definition for one or more
-beans. If any profile is enabled, the default profile does not apply.
+If no profile is active, the `dataSource` is created. You can see this
+as a way to provide a default definition for one or more beans. If any
+profile is enabled, the default profile does not apply.

-The name of the default profile is `default`. You can change the name of
-the default profile by using `setDefaultProfiles()` on the `Environment` or,
-declaratively, by using the `spring.profiles.default` property.
+You can change the name of the default profile by using `setDefaultProfiles()` on
+the `Environment` or, declaratively, by using the `spring.profiles.default` property.



@@ -599,17 +598,17 @@ Kotlin::

 In the preceding snippet, we see a high-level way of asking Spring whether the `my-property` property is
 defined for the current environment. To answer this question, the `Environment` object performs
-a search over a set of {spring-framework-api}/core/env/PropertySource.html[`PropertySource`]
+a search over a set of {api-spring-framework}/core/env/PropertySource.html[`PropertySource`]
 objects. A `PropertySource` is a simple abstraction over any source of key-value pairs, and
-Spring's {spring-framework-api}/core/env/StandardEnvironment.html[`StandardEnvironment`]
+Spring's {api-spring-framework}/core/env/StandardEnvironment.html[`StandardEnvironment`]
 is configured with two PropertySource objects -- one representing the set of JVM system properties
 (`System.getProperties()`) and one representing the set of system environment variables
 (`System.getenv()`).

 NOTE: These default property sources are present for `StandardEnvironment`, for use in standalone
-applications. {spring-framework-api}/web/context/support/StandardServletEnvironment.html[`StandardServletEnvironment`]
+applications. {api-spring-framework}/web/context/support/StandardServletEnvironment.html[`StandardServletEnvironment`]
 is populated with additional default property sources including servlet config, servlet
-context parameters, and a {spring-framework-api}/jndi/JndiPropertySource.html[`JndiPropertySource`]
+context parameters, and a {api-spring-framework}/jndi/JndiPropertySource.html[`JndiPropertySource`]
 if JNDI is available.

 Concretely, when you use the `StandardEnvironment`, the call to `env.containsProperty("my-property")`
@@ -663,7 +662,7 @@ Kotlin::
 In the preceding code, `MyPropertySource` has been added with highest precedence in the
 search. If it contains a  `my-property` property, the property is detected and returned, in favor of
 any `my-property` property in any other `PropertySource`. The
-{spring-framework-api}/core/env/MutablePropertySources.html[`MutablePropertySources`]
+{api-spring-framework}/core/env/MutablePropertySources.html[`MutablePropertySources`]
 API exposes a number of methods that allow for precise manipulation of the set of
 property sources.

@@ -672,7 +671,7 @@ property sources.
 [[beans-using-propertysource]]
 == Using `@PropertySource`

-The {spring-framework-api}/context/annotation/PropertySource.html[`@PropertySource`]
+The {api-spring-framework}/context/annotation/PropertySource.html[`@PropertySource`]
 annotation provides a convenient and declarative mechanism for adding a `PropertySource`
 to Spring's `Environment`.

@@ -772,9 +771,11 @@ resolved to the corresponding value. If not, then `default/path` is used
 as a default. If no default is specified and a property cannot be resolved, an
 `IllegalArgumentException` is thrown.

-NOTE: `@PropertySource` can be used as a repeatable annotation. `@PropertySource`
-may also be used as a meta-annotation to create custom composed annotations with
-attribute overrides.
+NOTE: The `@PropertySource` annotation is repeatable, according to Java 8 conventions.
+However, all such `@PropertySource` annotations need to be declared at the same
+level, either directly on the configuration class or as meta-annotations within the
+same custom annotation. Mixing direct annotations and meta-annotations is not
+recommended, since direct annotations effectively override meta-annotations.



@@ -22,9 +22,10 @@ in which these `BeanPostProcessor` instances run by setting the `order` property
 You can set this property only if the `BeanPostProcessor` implements the `Ordered`
 interface. If you write your own `BeanPostProcessor`, you should consider implementing
 the `Ordered` interface, too. For further details, see the javadoc of the
-{spring-framework-api}/beans/factory/config/BeanPostProcessor.html[`BeanPostProcessor`]
-and {spring-framework-api}/core/Ordered.html[`Ordered`] interfaces. See also the note on
-xref:core/beans/factory-extension.adoc#beans-factory-programmatically-registering-beanpostprocessors[programmatic registration of `BeanPostProcessor` instances].
+{api-spring-framework}/beans/factory/config/BeanPostProcessor.html[`BeanPostProcessor`]
+and {api-spring-framework}/core/Ordered.html[`Ordered`] interfaces. See also the note
+on xref:core/beans/factory-extension.adoc#beans-factory-programmatically-registering-beanpostprocessors[programmatic registration of `BeanPostProcessor` instances]
+.

 [NOTE]
 ====
@@ -272,19 +273,18 @@ which these `BeanFactoryPostProcessor` instances run by setting the `order` prop
 However, you can only set this property if the `BeanFactoryPostProcessor` implements the
 `Ordered` interface. If you write your own `BeanFactoryPostProcessor`, you should
 consider implementing the `Ordered` interface, too. See the javadoc of the
-{spring-framework-api}/beans/factory/config/BeanFactoryPostProcessor.html[`BeanFactoryPostProcessor`]
-and {spring-framework-api}/core/Ordered.html[`Ordered`] interfaces for more details.
+{api-spring-framework}/beans/factory/config/BeanFactoryPostProcessor.html[`BeanFactoryPostProcessor`]
+and {api-spring-framework}/core/Ordered.html[`Ordered`] interfaces for more details.

 [NOTE]
 ====
 If you want to change the actual bean instances (that is, the objects that are created
 from the configuration metadata), then you instead need to use a `BeanPostProcessor`
-(described earlier in
-xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp[Customizing Beans by Using a `BeanPostProcessor`]).
-While it is technically possible to work with bean instances within a `BeanFactoryPostProcessor`
-(for example, by using `BeanFactory.getBean()`), doing so causes premature bean instantiation,
-violating the standard container lifecycle. This may cause negative side effects, such as
-bypassing bean post processing.
+(described earlier in xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp[Customizing Beans by Using a `BeanPostProcessor`]). While it is technically possible
+to work with bean instances within a `BeanFactoryPostProcessor` (for example, by using
+`BeanFactory.getBean()`), doing so causes premature bean instantiation, violating the
+standard container lifecycle. This may cause negative side effects, such as bypassing
+bean post processing.

 Also, `BeanFactoryPostProcessor` instances are scoped per-container. This is only relevant
 if you use container hierarchies. If you define a `BeanFactoryPostProcessor` in one
@@ -331,7 +331,8 @@ with placeholder values is defined:
 		<property name="locations" value="classpath:com/something/jdbc.properties"/>
 	</bean>

-	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
+	<bean id="dataSource" destroy-method="close"
+			class="org.apache.commons.dbcp.BasicDataSource">
 		<property name="driverClassName" value="${jdbc.driverClassName}"/>
 		<property name="url" value="${jdbc.url}"/>
 		<property name="username" value="${jdbc.username}"/>
@@ -372,17 +373,6 @@ The `PropertySourcesPlaceholderConfigurer` not only looks for properties in the
 file you specify. By default, if it cannot find a property in the specified properties files,
 it checks against Spring `Environment` properties and regular Java `System` properties.

-[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, you should create your own
-`PropertySourcesPlaceholderConfigurer` bean that gathers the properties to use.
-=====
-
 [TIP]
 =====
 You can use the `PropertySourcesPlaceholderConfigurer` to substitute class names, which
@@ -443,8 +433,8 @@ This example file can be used with a container definition that contains a bean c

 Compound property names are also supported, as long as every component of the path
 except the final property being overridden is already non-null (presumably initialized
-by the constructors). In the following example, the `sammy` property of the `bob`
-property of the `fred` property of the `tom` bean is set to the scalar value `123`:
+by the constructors). In the following example, the `sammy` property of the `bob` property of the `fred` property of the `tom` bean
+is set to the scalar value `123`:

 [literal,subs="verbatim,quotes"]
 ----
@@ -42,7 +42,6 @@ startup and shutdown process, as driven by the container's own lifecycle.
 The lifecycle callback interfaces are described in this section.


-
 [[beans-factory-lifecycle-initializingbean]]
 === Initialization Callbacks

@@ -133,30 +132,6 @@ Kotlin::

 However, the first of the two preceding examples does not couple the code to Spring.

-[NOTE]
-====
-Be aware that `@PostConstruct` and initialization methods in general are executed
-within the container's singleton creation lock. The bean instance is only considered
-as fully initialized and ready to be published to others after returning from the
-`@PostConstruct` method. Such individual initialization methods are only meant
-for validating the configuration state and possibly preparing some data structures
-based on the given configuration but no further activity with external bean access.
-Otherwise there is a risk for an initialization deadlock.
-
-For a scenario where expensive post-initialization activity is to be triggered,
-e.g. asynchronous database preparation steps, your bean should either implement
-`SmartInitializingSingleton.afterSingletonsInstantiated()` or rely on the context
-refresh event: implementing `ApplicationListener<ContextRefreshedEvent>` or
-declaring its annotation equivalent `@EventListener(ContextRefreshedEvent.class)`.
-Those variants come after all regular singleton initialization and therefore
-outside of any singleton creation lock.
-
-Alternatively, you may implement the `(Smart)Lifecycle` interface and integrate with
-the container's overall lifecycle management, including an auto-startup mechanism,
-a pre-destroy stop step, and potential stop/restart callbacks (see below).
-====
-
-

 [[beans-factory-lifecycle-disposablebean]]
 === Destruction Callbacks
@@ -180,7 +155,7 @@ xref:core/beans/java/bean-annotation.adoc#beans-java-lifecycle-callbacks[Receivi

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
-	<bean id="exampleDestructionBean" class="examples.ExampleBean" destroy-method="cleanup"/>
+	<bean id="exampleInitBean" class="examples.ExampleBean" destroy-method="cleanup"/>
 ----

 [tabs]
@@ -214,7 +189,7 @@ The preceding definition has almost exactly the same effect as the following def

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
-	<bean id="exampleDestructionBean" class="examples.AnotherExampleBean"/>
+	<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>
 ----

 [tabs]
@@ -247,45 +222,32 @@ Kotlin::

 However, the first of the two preceding definitions does not couple the code to Spring.

-Note that Spring also supports inference of destroy methods, detecting a public `close` or
-`shutdown` method. This is the default behavior for `@Bean` methods in Java configuration
-classes and automatically matches `java.lang.AutoCloseable` or `java.io.Closeable`
-implementations, not coupling the destruction logic to Spring either.
-
-TIP: For destroy method inference with XML, you may assign the `destroy-method` attribute
-of a `<bean>` element a special `(inferred)` value, which instructs Spring to automatically
-detect a public `close` or `shutdown` method on the bean class for a specific bean definition.
-You can also set this special `(inferred)` value on the `default-destroy-method` attribute
-of a `<beans>` element to apply this behavior to an entire set of bean definitions (see
-xref:core/beans/factory-nature.adoc#beans-factory-lifecycle-default-init-destroy-methods[Default Initialization and Destroy Methods]).
-
-[NOTE]
-====
-For extended shutdown phases, you may implement the `Lifecycle` interface and receive
-an early stop signal before the destroy methods of any singleton beans are called.
-You may also implement `SmartLifecycle` for a time-bound stop step where the container
-will wait for all such stop processing to complete before moving on to destroy methods.
-====
-
-
+TIP: You can assign the `destroy-method` attribute of a `<bean>` element a special
+`(inferred)` value, which instructs Spring to automatically detect a public `close` or
+`shutdown` method on the specific bean class. (Any class that implements
+`java.lang.AutoCloseable` or `java.io.Closeable` would therefore match.) You can also set
+this special `(inferred)` value on the `default-destroy-method` attribute of a
+`<beans>` element to apply this behavior to an entire set of beans (see
+xref:core/beans/factory-nature.adoc#beans-factory-lifecycle-default-init-destroy-methods[Default Initialization and Destroy Methods]). Note that this is the
+default behavior with Java configuration.

 [[beans-factory-lifecycle-default-init-destroy-methods]]
 === Default Initialization and Destroy Methods

 When you write initialization and destroy method callbacks that do not use the
 Spring-specific `InitializingBean` and `DisposableBean` callback interfaces, you
-typically write methods with names such as `init()`, `initialize()`, `dispose()`,
-and so on. Ideally, the names of such lifecycle callback methods are standardized across
-a project so that all developers use the same method names and ensure consistency.
+typically write methods with names such as `init()`, `initialize()`, `dispose()`, and so
+on. Ideally, the names of such lifecycle callback methods are standardized across a
+project so that all developers use the same method names and ensure consistency.

 You can configure the Spring container to "`look`" for named initialization and destroy
-callback method names on every bean. This means that you, as an application developer,
-can write your application classes and use an initialization callback called `init()`,
-without having to configure an `init-method="init"` attribute with each bean definition.
-The Spring IoC container calls that method when the bean is created (and in accordance
-with the standard lifecycle callback contract xref:core/beans/factory-nature.adoc#beans-factory-lifecycle[described previously]).
-This feature also enforces a consistent naming convention for initialization and
-destroy method callbacks.
+callback method names on every bean. This means that you, as an application
+developer, can write your application classes and use an initialization callback called
+`init()`, without having to configure an `init-method="init"` attribute with each bean
+definition. The Spring IoC container calls that method when the bean is created (and in
+accordance with the standard lifecycle callback contract xref:core/beans/factory-nature.adoc#beans-factory-lifecycle[described previously]
+). This feature also enforces a consistent naming convention for
+initialization and destroy method callbacks.

 Suppose that your initialization callback methods are named `init()` and your destroy
 callback methods are named `destroy()`. Your class then resembles the class in the
@@ -445,15 +407,14 @@ and closed.
 [TIP]
 ====
 Note that the regular `org.springframework.context.Lifecycle` interface is a plain
-contract for explicit start and stop notifications and does not imply auto-startup
-at context refresh time. For fine-grained control over auto-startup and for graceful
-stopping of a specific bean (including startup and stop phases), consider implementing
-the extended `org.springframework.context.SmartLifecycle` interface instead.
+contract for explicit start and stop notifications and does not imply auto-startup at context
+refresh time. For fine-grained control over auto-startup of a specific bean (including startup phases),
+consider implementing `org.springframework.context.SmartLifecycle` instead.

 Also, please note that stop notifications are not guaranteed to come before destruction.
 On regular shutdown, all `Lifecycle` beans first receive a stop notification before
-the general destruction callbacks are being propagated. However, on hot refresh during
-a context's lifetime or on stopped refresh attempts, only destroy methods are called.
+the general destruction callbacks are being propagated. However, on hot refresh during a
+context's lifetime or on stopped refresh attempts, only destroy methods are called.
 ====

 The order of startup and shutdown invocations can be important. If a "`depends-on`"
@@ -51,7 +51,7 @@ The following table describes the supported scopes:

 NOTE: A thread scope is available but is not registered by default. For more information,
 see the documentation for
-{spring-framework-api}/context/support/SimpleThreadScope.html[`SimpleThreadScope`].
+{api-spring-framework}/context/support/SimpleThreadScope.html[`SimpleThreadScope`].
 For instructions on how to register this or any other custom scope, see
 xref:core/beans/factory-scopes.adoc#beans-factory-scopes-custom-using[Using a Custom Scope].

@@ -125,8 +125,8 @@ objects regardless of scope, in the case of prototypes, configured destruction
 lifecycle callbacks are not called. The client code must clean up prototype-scoped
 objects and release expensive resources that the prototype beans hold. To get
 the Spring container to release resources held by prototype-scoped beans, try using a
-custom xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp[bean post-processor]
-which holds a reference to beans that need to be cleaned up.
+custom xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp[bean post-processor], which holds a reference to
+beans that need to be cleaned up.

 In some respects, the Spring container's role in regard to a prototype-scoped bean is a
 replacement for the Java `new` operator. All lifecycle management past that point must
@@ -449,13 +449,12 @@ understand the "`why`" as well as the "`how`" behind it:
 ----
 <1> The line that defines the proxy.

-To create such a proxy, you insert a child `<aop:scoped-proxy/>` element into a
-scoped bean definition (see
-xref:core/beans/factory-scopes.adoc#beans-factory-scopes-other-injection-proxies[Choosing the Type of Proxy to Create]
-and xref:core/appendix/xsd-schemas.adoc[XML Schema-based configuration]).

+To create such a proxy, you insert a child `<aop:scoped-proxy/>` element into a scoped
+bean definition (see xref:core/beans/factory-scopes.adoc#beans-factory-scopes-other-injection-proxies[Choosing the Type of Proxy to Create] and
+xref:core/appendix/xsd-schemas.adoc[XML Schema-based configuration]).
 Why do definitions of beans scoped at the `request`, `session` and custom-scope
-levels require the `<aop:scoped-proxy/>` element in common scenarios?
+levels require the `<aop:scoped-proxy/>` element?
 Consider the following singleton bean definition and contrast it with
 what you need to define for the aforementioned scopes (note that the following
 `userPreferences` bean definition as it stands is incomplete):
@@ -514,8 +513,8 @@ the `<aop:scoped-proxy/>` element, a CGLIB-based class proxy is created.

 [NOTE]
 ====
-CGLIB proxies do not intercept private methods. Attempting to call a private method
-on such a proxy will not delegate to the actual scoped target object.
+CGLIB proxies intercept only public method calls! Do not call non-public methods
+on such a proxy. They are not delegated to the actual scoped target object.
 ====

 Alternatively, you can configure the Spring container to create standard JDK
@@ -559,7 +558,7 @@ To integrate your custom scopes into the Spring container, you need to implement
 `org.springframework.beans.factory.config.Scope` interface, which is described in this
 section. For an idea of how to implement your own scopes, see the `Scope`
 implementations that are supplied with the Spring Framework itself and the
-{spring-framework-api}/beans/factory/config/Scope.html[`Scope`] javadoc,
+{api-spring-framework}/beans/factory/config/Scope.html[`Scope`] javadoc,
 which explains the methods you need to implement in more detail.

 The `Scope` interface has four methods to get objects from the scope, remove them from
@@ -629,7 +628,7 @@ Kotlin::
 ----
 ======

-See the {spring-framework-api}/beans/factory/config/Scope.html#registerDestructionCallback[javadoc]
+See the {api-spring-framework}/beans/factory/config/Scope.html#registerDestructionCallback[javadoc]
 or a Spring scope implementation for more information on destruction callbacks.

 The following method obtains the conversation identifier for the underlying scope:
@@ -1,22 +1,22 @@
 [[beans-introduction]]
 = Introduction to the Spring IoC Container and Beans

-This chapter covers the Spring Framework implementation of the Inversion of Control (IoC)
-principle. Dependency injection (DI) is a specialized form of IoC, whereby objects define
-their dependencies (that is, the other objects they work with) only through constructor
-arguments, arguments to a factory method, or properties that are set on the object
-instance after it is constructed or returned from a factory method. The IoC container
+This chapter covers the Spring Framework implementation of the Inversion of Control
+(IoC) principle. IoC is also known as dependency injection (DI). It is a process whereby
+objects define their dependencies (that is, the other objects they work with) only through
+constructor arguments, arguments to a factory method, or properties that are set on the
+object instance after it is constructed or returned from a factory method. The container
 then injects those dependencies when it creates the bean. This process is fundamentally
-the inverse (hence the name, Inversion of Control) of the bean itself controlling the
-instantiation or location of its dependencies by using direct construction of classes or
-a mechanism such as the Service Locator pattern.
+the inverse (hence the name, Inversion of Control) of the bean itself
+controlling the instantiation or location of its dependencies by using direct
+construction of classes or a mechanism such as the Service Locator pattern.

 The `org.springframework.beans` and `org.springframework.context` packages are the basis
 for Spring Framework's IoC container. The
-{spring-framework-api}/beans/factory/BeanFactory.html[`BeanFactory`]
+{api-spring-framework}/beans/factory/BeanFactory.html[`BeanFactory`]
 interface provides an advanced configuration mechanism capable of managing any type of
 object.
-{spring-framework-api}/context/ApplicationContext.html[`ApplicationContext`]
+{api-spring-framework}/context/ApplicationContext.html[`ApplicationContext`]
 is a sub-interface of `BeanFactory`. It adds:

 * Easier integration with Spring's AOP features
@@ -3,5 +3,17 @@
 :page-section-summary-toc: 1

 This section covers how to use annotations in your Java code to configure the Spring
-container.
+container. It includes the following topics:
+
+* xref:core/beans/java/basic-concepts.adoc[Basic Concepts: `@Bean` and `@Configuration`]
+* xref:core/beans/java/instantiating-container.adoc[Instantiating the Spring Container by Using `AnnotationConfigApplicationContext`]
+* xref:core/beans/java/bean-annotation.adoc[Using the `@Bean` Annotation]
+* xref:core/beans/java/configuration-annotation.adoc[Using the `@Configuration` annotation]
+* xref:core/beans/java/composing-configuration-classes.adoc[Composing Java-based Configurations]
+* xref:core/beans/environment.adoc#beans-definition-profiles[Bean Definition Profiles]
+* xref:core/beans/environment.adoc#beans-property-source-abstraction[`PropertySource` Abstraction]
+* xref:core/beans/environment.adoc#beans-using-propertysource[Using `@PropertySource`]
+* xref:core/beans/environment.adoc#beans-placeholder-resolution-in-statements[Placeholder Resolution in Statements]
+
+

@@ -59,7 +59,7 @@ The preceding `AppConfig` class is equivalent to the following Spring `<beans/>`
 ****
 When `@Bean` methods are declared within classes that are not annotated with
 `@Configuration`, they are referred to as being processed in a "`lite`" mode. Bean methods
-declared on a bean that is not annotated with `@Configuration` are considered to be "`lite`",
+declared in a `@Component` or even in a plain old class are considered to be "`lite`",
 with a different primary purpose of the containing class and a `@Bean` method
 being a sort of bonus there. For example, service components may expose management views
 to the container through an additional `@Bean` method on each applicable component class.
@@ -180,10 +180,9 @@ Kotlin::
 ----
 ======

+
 The resolution mechanism is pretty much identical to constructor-based dependency
-injection. See
-xref:core/beans/dependencies/factory-collaborators.adoc#beans-constructor-injection[the relevant section]
-for more details.
+injection. See xref:core/beans/dependencies/factory-collaborators.adoc#beans-constructor-injection[the relevant section] for more details.


 [[beans-java-lifecycle-callbacks]]
@@ -318,9 +317,8 @@ type, making it harder to use for cross-reference calls in other `@Bean` methods
 intend to refer to the provided resource here).
 =====

-In the case of `BeanOne` from the example above the preceding note, it would be
-equally valid to call the `init()` method directly during construction, as the
-following example shows:
+In the case of `BeanOne` from the example above the preceding note, it would be equally valid to call the `init()`
+method directly during construction, as the following example shows:

 [tabs]
 ======
@@ -508,10 +506,10 @@ Kotlin::
 [[beans-java-bean-aliasing]]
 == Bean Aliasing

-As discussed in xref:core/beans/definition.adoc#beans-beanname[Naming Beans], it is
-sometimes desirable to give a single bean multiple names, otherwise known as bean aliasing.
-The `name` attribute of the `@Bean` annotation accepts a String array for this purpose.
-The following example shows how to set a number of aliases for a bean:
+As discussed in xref:core/beans/definition.adoc#beans-beanname[Naming Beans], it is sometimes desirable to give a single bean
+multiple names, otherwise known as bean aliasing. The `name` attribute of the `@Bean`
+annotation accepts a String array for this purpose. The following example shows how to set
+a number of aliases for a bean:

 [tabs]
 ======
@@ -552,7 +550,7 @@ Sometimes, it is helpful to provide a more detailed textual description of a bea
 be particularly useful when beans are exposed (perhaps through JMX) for monitoring purposes.

 To add a description to a `@Bean`, you can use the
-{spring-framework-api}/context/annotation/Description.html[`@Description`]
+{api-spring-framework}/context/annotation/Description.html[`@Description`]
 annotation, as the following example shows:

 [tabs]
@@ -113,8 +113,7 @@ issue, because no compiler is involved, and you can declare
 When using `@Configuration` classes, the Java compiler places constraints on
 the configuration model, in that references to other beans must be valid Java syntax.

-Fortunately, solving this problem is simple. As
-xref:core/beans/java/bean-annotation.adoc#beans-java-dependencies[we already discussed],
+Fortunately, solving this problem is simple. As xref:core/beans/java/bean-annotation.adoc#beans-java-dependencies[we already discussed],
 a `@Bean` method can have an arbitrary number of parameters that describe the bean
 dependencies. Consider the following more real-world scenario with several `@Configuration`
 classes, each depending on beans declared in the others:
@@ -205,6 +204,7 @@ Kotlin::
 ----
 ======

+
 There is another way to achieve the same result. Remember that `@Configuration` classes are
 ultimately only another bean in the container: This means that they can take advantage of
 `@Autowired` and `@Value` injection and other features the same as any other bean.
@@ -216,16 +216,11 @@ classes are processed quite early during the initialization of the context, and
 to be injected this way may lead to unexpected early initialization. Whenever possible, resort to
 parameter-based injection, as in the preceding example.

-Avoid access to locally defined beans within a `@PostConstruct` method on the same configuration
-class. This effectively leads to a circular reference since non-static `@Bean` methods semantically
-require a fully initialized configuration class instance to be called on. With circular references
-disallowed (e.g. in Spring Boot 2.6+), this may trigger a `BeanCurrentlyInCreationException`.
-
 Also, be particularly careful with `BeanPostProcessor` and `BeanFactoryPostProcessor` definitions
 through `@Bean`. Those should usually be declared as `static @Bean` methods, not triggering the
 instantiation of their containing configuration class. Otherwise, `@Autowired` and `@Value` may not
 work on the configuration class itself, since it is possible to create it as a bean instance earlier than
-{spring-framework-api}/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.html[`AutowiredAnnotationBeanPostProcessor`].
+{api-spring-framework}/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.html[`AutowiredAnnotationBeanPostProcessor`].
 ====

 The following example shows how one bean can be autowired to another bean:
@@ -338,7 +333,7 @@ modularity, but determining exactly where the autowired bean definitions are dec
 still somewhat ambiguous. For example, as a developer looking at `ServiceConfig`, how do
 you know exactly where the `@Autowired AccountRepository` bean is declared? It is not
 explicit in the code, and this may be just fine. Remember that the
-{spring-site-tools}[Spring Tools for Eclipse] provides tooling that
+https://spring.io/tools[Spring Tools for Eclipse] provides tooling that
 can render graphs showing how everything is wired, which may be all you need. Also,
 your Java IDE can easily find all declarations and uses of the `AccountRepository` type
 and quickly show you the location of `@Bean` methods that return that type.
@@ -519,7 +514,7 @@ profile has been enabled in the Spring `Environment` (see xref:core/beans/enviro
 for details).

 The `@Profile` annotation is actually implemented by using a much more flexible annotation
-called {spring-framework-api}/context/annotation/Conditional.html[`@Conditional`].
+called {api-spring-framework}/context/annotation/Conditional.html[`@Conditional`].
 The `@Conditional` annotation indicates specific
 `org.springframework.context.annotation.Condition` implementations that should be
 consulted before a `@Bean` is registered.
@@ -570,7 +565,7 @@ Kotlin::
 ----
 ======

-See the {spring-framework-api}/context/annotation/Conditional.html[`@Conditional`]
+See the {api-spring-framework}/context/annotation/Conditional.html[`@Conditional`]
 javadoc for more detail.


@@ -278,7 +278,7 @@ init-param):

 NOTE: For programmatic use cases, a `GenericWebApplicationContext` can be used as an
 alternative to `AnnotationConfigWebApplicationContext`. See the
-{spring-framework-api}/web/context/support/GenericWebApplicationContext.html[`GenericWebApplicationContext`]
+{api-spring-framework}/web/context/support/GenericWebApplicationContext.html[`GenericWebApplicationContext`]
 javadoc for details.


@@ -56,7 +56,7 @@ alternate between read and write.
 == `PooledDataBuffer`

 As explained in the Javadoc for
-{java-api}/java.base/java/nio/ByteBuffer.html[ByteBuffer],
+https://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html[ByteBuffer],
 byte buffers can be direct or non-direct. Direct buffers may reside outside the Java heap
 which eliminates the need for copying for native I/O operations. That makes direct buffers
 particularly useful for receiving and sending data over a socket, but they're also more
@@ -11,7 +11,7 @@ EL, to name a few -- the Spring Expression Language was created to provide the S
 community with a single well supported expression language that can be used across all
 the products in the Spring portfolio. Its language features are driven by the
 requirements of the projects in the Spring portfolio, including tooling requirements
-for code completion support within the {spring-site-tools}[Spring Tools for Eclipse].
+for code completion support within the https://spring.io/tools[Spring Tools for Eclipse].
 That said, SpEL is based on a technology-agnostic API that lets other expression language
 implementations be integrated, should the need arise.

@@ -46,9 +46,7 @@ The expression language supports the following functionality:
 * Inline maps
 * Ternary operator
 * Variables
-* User-defined functions added to the context
-  * reflective invocation of `Method`
-  * various cases of `MethodHandle`
+* User-defined functions
 * Collection projection
 * Collection selection
 * Templated expressions
@@ -2,4 +2,24 @@
 = Language Reference
 :page-section-summary-toc: 1

-This section describes how the Spring Expression Language works.
+This section describes how the Spring Expression Language works. It covers the following
+topics:
+
+* xref:core/expressions/language-ref/literal.adoc[Literal Expressions]
+* xref:core/expressions/language-ref/properties-arrays.adoc[Properties, Arrays, Lists, Maps, and Indexers]
+* xref:core/expressions/language-ref/inline-lists.adoc[Inline Lists]
+* xref:core/expressions/language-ref/inline-maps.adoc[Inline Maps]
+* xref:core/expressions/language-ref/array-construction.adoc[Array Construction]
+* xref:core/expressions/language-ref/methods.adoc[Methods]
+* xref:core/expressions/language-ref/operators.adoc[Operators]
+* xref:core/expressions/language-ref/types.adoc[Types]
+* xref:core/expressions/language-ref/constructors.adoc[Constructors]
+* xref:core/expressions/language-ref/variables.adoc[Variables]
+* xref:core/expressions/language-ref/functions.adoc[Functions]
+* xref:core/expressions/language-ref/bean-references.adoc[Bean References]
+* xref:core/expressions/language-ref/operator-ternary.adoc[Ternary Operator (If-Then-Else)]
+* xref:core/expressions/language-ref/operator-elvis.adoc[The Elvis Operator]
+* xref:core/expressions/language-ref/operator-safe-navigation.adoc[Safe Navigation Operator]
+
+
+
@@ -3,8 +3,7 @@

 You can extend SpEL by registering user-defined functions that can be called within the
 expression string. The function is registered through the `EvaluationContext`. The
-following example shows how to register a user-defined function to be invoked via reflection
-(i.e. a `Method`):
+following example shows how to register a user-defined function:

 [tabs]
 ======
@@ -95,97 +94,5 @@ Kotlin::
 ----
 ======

-The use of `MethodHandle` is also supported. This enables potentially more efficient use
-cases if the `MethodHandle` target and parameters have been fully bound prior to
-registration, but partially bound handles are also supported.
-
-Consider the `String#formatted(String, Object...)` instance method, which produces a
-message according to a template and a variable number of arguments.
-
-You can register and use the `formatted` method as a `MethodHandle`, as the following
-example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
-
-	MethodHandle mh = MethodHandles.lookup().findVirtual(String.class, "formatted",
-			MethodType.methodType(String.class, Object[].class));
-	context.setVariable("message", mh);
-
-	String message = parser.parseExpression("#message('Simple message: <%s>', 'Hello World', 'ignored')")
-			.getValue(context, String.class);
-	//returns "Simple message: <Hello World>"
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
-
-	val mh = MethodHandles.lookup().findVirtual(String::class.java, "formatted",
-			MethodType.methodType(String::class.java, Array<Any>::class.java))
-	context.setVariable("message", mh)
-
-	val message = parser.parseExpression("#message('Simple message: <%s>', 'Hello World', 'ignored')")
-			.getValue(context, String::class.java)
----
-======
-
-As hinted above, binding a `MethodHandle` and registering the bound `MethodHandle` is also
-supported. This is likely to be more performant if both the target and all the arguments
-are bound. In that case no arguments are necessary in the SpEL expression, as the
-following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
-
-	String template = "This is a %s message with %s words: <%s>";
-	Object varargs = new Object[] { "prerecorded", 3, "Oh Hello World!", "ignored" };
-	MethodHandle mh = MethodHandles.lookup().findVirtual(String.class, "formatted",
-			MethodType.methodType(String.class, Object[].class))
-			.bindTo(template)
-			.bindTo(varargs); //here we have to provide arguments in a single array binding
-	context.setVariable("message", mh);
-
-	String message = parser.parseExpression("#message()")
-			.getValue(context, String.class);
-	//returns "This is a prerecorded message with 3 words: <Oh Hello World!>"
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
-
-	val template = "This is a %s message with %s words: <%s>"
-	val varargs = arrayOf("prerecorded", 3, "Oh Hello World!", "ignored")
-
-	val mh = MethodHandles.lookup().findVirtual(String::class.java, "formatted",
-			MethodType.methodType(String::class.java, Array<Any>::class.java))
-			.bindTo(template)
-			.bindTo(varargs) //here we have to provide arguments in a single array binding
-	context.setVariable("message", mh)
-
-	val message = parser.parseExpression("#message()")
-			.getValue(context, String::class.java)
----
-======
-


@@ -38,10 +38,6 @@ Kotlin::
 ----
 ======

-NOTE: The SpEL Elvis operator also checks for _empty_ Strings in addition to `null` objects.
-The original snippet is thus only close to emulating the semantics of the operator (it would need an
-additional `!name.isEmpty()` check).
-
 The following listing shows a more complex example:

 [tabs]
@@ -57,7 +53,7 @@ Java::
 	String name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String.class);
 	System.out.println(name);  // Nikola Tesla

-	tesla.setName("");
+	tesla.setName(null);
 	name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String.class);
 	System.out.println(name);  // Elvis Presley
 ----
@@ -73,7 +69,7 @@ Kotlin::
 	var name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String::class.java)
 	println(name)  // Nikola Tesla

-	tesla.setName("")
+	tesla.setName(null)
 	name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String::class.java)
 	println(name)  // Elvis Presley
 ----
@@ -38,15 +38,5 @@ Kotlin::
 ----
 ======

-[NOTE]
-====
-If your application or framework manages its own `EvaluationContext`, you may need to
-manually configure a `StandardTypeLocator` with a specific `ClassLoader` to ensure that
-the SpEL expression parser is able to reliably locate user types.
-
-For example, the `StandardBeanExpressionResolver` in the `spring-context` module
-configures a `StandardTypeLocator` using the bean `ClassLoader` of the corresponding
-`BeanFactory`.
-====


@@ -1,8 +1,8 @@
 [[expressions-ref-variables]]
 = Variables

-You can reference variables in an expression by using the `#variableName` syntax. Variables
-are set by using the `setVariable()` method in `EvaluationContext` implementations.
+You can reference variables in the expression by using the `#variableName` syntax. Variables
+are set by using the `setVariable` method on `EvaluationContext` implementations.

 [NOTE]
 ====
@@ -29,7 +29,7 @@ Java::
 	context.setVariable("newName", "Mike Tesla");

 	parser.parseExpression("name = #newName").getValue(context, tesla);
-	System.out.println(tesla.getName());  // "Mike Tesla"
+	System.out.println(tesla.getName())  // "Mike Tesla"
 ----

 Kotlin::
@@ -53,10 +53,8 @@ Kotlin::
 The `#this` variable is always defined and refers to the current evaluation object
 (against which unqualified references are resolved). The `#root` variable is always
 defined and refers to the root context object. Although `#this` may vary as components of
-an expression are evaluated, `#root` always refers to the root.
-
-The following example shows how to use the `#this` variable in conjunction with
-xref:core/expressions/language-ref/collection-selection.adoc[collection selection].
+an expression are evaluated, `#root` always refers to the root. The following examples
+show how to use the `#this` and `#root` variables:

 [tabs]
 ======
@@ -64,95 +62,40 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	// Create a list of prime integers.
-	List<Integer> primes = List.of(2, 3, 5, 7, 11, 13, 17);
+	// create an array of integers
+	List<Integer> primes = new ArrayList<>();
+	primes.addAll(Arrays.asList(2,3,5,7,11,13,17));

-	// Create parser and set variable 'primes' as the list of integers.
+	// create parser and set variable 'primes' as the array of integers
 	ExpressionParser parser = new SpelExpressionParser();
-	EvaluationContext context = SimpleEvaluationContext.forReadWriteDataBinding().build();
+	EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataAccess();
 	context.setVariable("primes", primes);

-	// Select all prime numbers > 10 from the list (using selection ?{...}).
-	String expression = "#primes.?[#this > 10]";
-
-	// Evaluates to a list containing [11, 13, 17].
-	List<Integer> primesGreaterThanTen =
-			parser.parseExpression(expression).getValue(context, List.class);
+	// all prime numbers > 10 from the list (using selection ?{...})
+	// evaluates to [11, 13, 17]
+	List<Integer> primesGreaterThanTen = (List<Integer>) parser.parseExpression(
+			"#primes.?[#this>10]").getValue(context);
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	// Create a list of prime integers.
-	val primes = listOf(2, 3, 5, 7, 11, 13, 17)
+	// create an array of integers
+	val primes = ArrayList<Int>()
+	primes.addAll(listOf(2, 3, 5, 7, 11, 13, 17))

-	// Create parser and set variable 'primes' as the list of integers.
+	// create parser and set variable 'primes' as the array of integers
 	val parser = SpelExpressionParser()
-	val context = SimpleEvaluationContext.forReadWriteDataBinding().build()
+	val context = SimpleEvaluationContext.forReadOnlyDataAccess()
 	context.setVariable("primes", primes)

-	// Select all prime numbers > 10 from the list (using selection ?{...}).
-	val expression = "#primes.?[#this > 10]"
-
-	// Evaluates to a list containing [11, 13, 17].
-	val primesGreaterThanTen = parser.parseExpression(expression)
-			.getValue(context) as List<Int>
+	// all prime numbers > 10 from the list (using selection ?{...})
+	// evaluates to [11, 13, 17]
+	val primesGreaterThanTen = parser.parseExpression(
+			"#primes.?[#this>10]").getValue(context) as List<Int>
 ----
 ======

-The following example shows how to use the `#this` and `#root` variables together in
-conjunction with
-xref:core/expressions/language-ref/collection-projection.adoc[collection projection].

-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	// Create parser and evaluation context.
-	ExpressionParser parser = new SpelExpressionParser();
-	EvaluationContext context = SimpleEvaluationContext.forReadWriteDataBinding().build();
-
-	// Create an inventor to use as the root context object.
-	Inventor tesla = new Inventor("Nikola Tesla");
-	tesla.setInventions("Telephone repeater", "Tesla coil transformer");
-
-	// Iterate over all inventions of the Inventor referenced as the #root
-	// object, and generate a list of strings whose contents take the form
-	// "<inventor's name> invented the <invention>." (using projection !{...}).
-	String expression = "#root.inventions.![#root.name + ' invented the ' + #this + '.']";
-
-	// Evaluates to a list containing:
-	// "Nikola Tesla invented the Telephone repeater."
-	// "Nikola Tesla invented the Tesla coil transformer."
-	List<String> results = parser.parseExpression(expression)
-			.getValue(context, tesla, List.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	// Create parser and evaluation context.
-	val parser = SpelExpressionParser()
-	val context = SimpleEvaluationContext.forReadWriteDataBinding().build()
-
-	// Create an inventor to use as the root context object.
-	val tesla = Inventor("Nikola Tesla")
-	tesla.setInventions("Telephone repeater", "Tesla coil transformer")
-
-	// Iterate over all inventions of the Inventor referenced as the #root
-	// object, and generate a list of strings whose contents take the form
-	// "<inventor's name> invented the <invention>." (using projection !{...}).
-	val expression = "#root.inventions.![#root.name + ' invented the ' + #this + '.']"
-
-	// Evaluates to a list containing:
-	// "Nikola Tesla invented the Telephone repeater."
-	// "Nikola Tesla invented the Tesla coil transformer."
-	val results = parser.parseExpression(expression)
-			.getValue(context, tesla, List::class.java)
----
-======

@@ -5,14 +5,14 @@ Although Java does not let you express null-safety with its type system, the Spr
 provides the following annotations in the `org.springframework.lang` package to let you
 declare nullability of APIs and fields:

-* {spring-framework-api}/lang/Nullable.html[`@Nullable`]: Annotation to indicate that a
+* {api-spring-framework}/lang/Nullable.html[`@Nullable`]: Annotation to indicate that a
 specific parameter, return value, or field can be `null`.
-* {spring-framework-api}/lang/NonNull.html[`@NonNull`]: Annotation to indicate that a specific
+* {api-spring-framework}/lang/NonNull.html[`@NonNull`]: Annotation to indicate that a specific
 parameter, return value, or field cannot be `null` (not needed on parameters, return values,
 and fields where `@NonNullApi` and `@NonNullFields` apply, respectively).
-* {spring-framework-api}/lang/NonNullApi.html[`@NonNullApi`]: Annotation at the package level
+* {api-spring-framework}/lang/NonNullApi.html[`@NonNullApi`]: Annotation at the package level
 that declares non-null as the default semantics for parameters and return values.
-* {spring-framework-api}/lang/NonNullFields.html[`@NonNullFields`]: Annotation at the package
+* {api-spring-framework}/lang/NonNullFields.html[`@NonNullFields`]: Annotation at the package
 level that declares non-null as the default semantics for fields.

 The Spring Framework itself leverages these annotations, but they can also be used in any
@@ -37,7 +37,7 @@ these annotations can be used by an IDE (such as IDEA or Eclipse) to provide use
 warnings related to null-safety in order to avoid `NullPointerException` at runtime.

 They are also used to make Spring APIs null-safe in Kotlin projects, since Kotlin natively
-supports {kotlin-docs}/null-safety.html[null-safety]. More details
+supports https://kotlinlang.org/docs/null-safety.html[null-safety]. More details
 are available in the xref:languages/kotlin/null-safety.adoc[Kotlin support documentation].


@@ -46,7 +46,7 @@ are available in the xref:languages/kotlin/null-safety.adoc[Kotlin support docum
 [[jsr-305-meta-annotations]]
 == JSR-305 meta-annotations

-Spring annotations are meta-annotated with {JSR}305[JSR 305]
+Spring annotations are meta-annotated with https://jcp.org/en/jsr/detail?id=305[JSR 305]
 annotations (a dormant but widespread JSR). JSR-305 meta-annotations let tooling vendors
 like IDEA or Kotlin provide null-safety support in a generic way, without having to
 hard-code support for Spring annotations.
@@ -37,7 +37,7 @@ such as a method to check for the existence of the resource being pointed to.
 Spring's `Resource` interface located in the `org.springframework.core.io.` package is
 meant to be a more capable interface for abstracting access to low-level resources. The
 following listing provides an overview of the `Resource` interface. See the
-{spring-framework-api}/core/io/Resource.html[`Resource`] javadoc for further details.
+{api-spring-framework}/core/io/Resource.html[`Resource`] javadoc for further details.


 [source,java,indent=0,subs="verbatim,quotes"]
@@ -104,7 +104,7 @@ resource (if the underlying implementation is compatible and supports that
 functionality).

 Some implementations of the `Resource` interface also implement the extended
-{spring-framework-api}/core/io/WritableResource.html[`WritableResource`] interface
+{api-spring-framework}/core/io/WritableResource.html[`WritableResource`] interface
 for a resource that supports writing to it.

 Spring itself uses the `Resource` abstraction extensively, as an argument type in
@@ -143,7 +143,7 @@ Spring includes several built-in `Resource` implementations:

 For a complete list of `Resource` implementations available in Spring, consult the
 "All Known Implementing Classes" section of the
-{spring-framework-api}/core/io/Resource.html[`Resource`] javadoc.
+{api-spring-framework}/core/io/Resource.html[`Resource`] javadoc.



@@ -763,7 +763,7 @@ Kotlin::
 ----
 ======

-See the {spring-framework-api}/context/support/ClassPathXmlApplicationContext.html[`ClassPathXmlApplicationContext`]
+See the {api-spring-framework}/context/support/ClassPathXmlApplicationContext.html[`ClassPathXmlApplicationContext`]
 javadoc for details on the various constructors.


@@ -903,7 +903,7 @@ entries in the classpath. When you build JARs with Ant, do not activate the `fil
 switch of the JAR task. Also, classpath directories may not get exposed based on security
 policies in some environments -- for example, stand-alone applications on JDK 1.7.0_45
 and higher (which requires 'Trusted-Library' to be set up in your manifests. See
-{stackoverflow-questions}/19394570/java-jre-7u45-breaks-classloader-getresources).
+https://stackoverflow.com/questions/19394570/java-jre-7u45-breaks-classloader-getresources).

 On JDK 9's module path (Jigsaw), Spring's classpath scanning generally works as expected.
 Putting resources into a dedicated directory is highly recommendable here as well,
@@ -9,7 +9,7 @@ known as _JUL_ or `java.util.logging`) if neither Log4j 2.x nor SLF4J is availab

 Put Log4j 2.x or Logback (or another SLF4J provider) in your classpath, without any extra
 bridges, and let the framework auto-adapt to your choice. For further information see the
-{spring-boot-docs}/features.html#features.logging[Spring
+https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-logging[Spring
 Boot Logging Reference Documentation].

 [NOTE]
@@ -1,57 +1,12 @@
-[[beans-binding]]
-= Data Binding
-
-Data binding is useful for binding user input to a target object where user input is a map
-with property paths as keys, following xref:beans-beans-conventions[JavaBeans conventions].
-`DataBinder` is the main class that supports this, and it provides two ways to bind user
-input:
-
- xref:beans-constructor-binding[Constructor binding] - bind user input to a public data
-constructor, looking up constructor argument values in the user input.
- xref:beans-beans[Property binding] - bind user input to setters, matching keys from the
-user input to properties of the target object structure.
-
-You can apply both constructor and property binding or only one.
-
-
-[[beans-constructor-binding]]
-== Constructor Binding
-
-To use constructor binding:
-
-1. Create a `DataBinder` with `null` as the target object.
-2. Set `targetType` to the target class.
-3. Call `construct`.
-
-The target class should have a single public constructor or a single non-public constructor
-with arguments. If there are multiple constructors, then a default constructor if present
-is used.
-
-By default, constructor parameter names are used to look up argument values, but you can
-configure a `NameResolver`. Spring MVC and WebFlux both rely to allow customizing the name
-of the value to bind through an `@BindParam` annotation on constructor parameters.
-
-xref:beans-beans-conventions[Type conversion] is applied as needed to convert user input.
-If the constructor parameter is an object, it is constructed recursively in the same
-manner, but through a nested property path. That means constructor binding creates both
-the target object and any objects it contains.
-
-Binding and conversion errors are reflected in the `BindingResult` of the `DataBinder`.
-If the target is created successfully, then `target` is set to the created instance
-after the call to `construct`.
-
-
-
-
 [[beans-beans]]
-== Property Binding with `BeanWrapper`
+= Bean Manipulation and the `BeanWrapper`

 The `org.springframework.beans` package adheres to the JavaBeans standard.
 A JavaBean is a class with a default no-argument constructor and that follows
 a naming convention where (for example) a property named `bingoMadness` would
 have a setter method `setBingoMadness(..)` and a getter method `getBingoMadness()`. For
 more information about JavaBeans and the specification, see
-{java-api}/java.desktop/java/beans/package-summary.html[javabeans].
+https://docs.oracle.com/javase/8/docs/api/java/beans/package-summary.html[javabeans].

 One quite important class in the beans package is the `BeanWrapper` interface and its
 corresponding implementation (`BeanWrapperImpl`). As quoted from the javadoc, the
@@ -71,7 +26,7 @@ perform actions on that bean, such as setting and retrieving properties.


 [[beans-beans-conventions]]
-=== Setting and Getting Basic and Nested Properties
+== Setting and Getting Basic and Nested Properties

 Setting and getting properties is done through the `setPropertyValue` and
 `getPropertyValue` overloaded method variants of `BeanWrapper`. See their Javadoc for
@@ -237,7 +192,7 @@ Kotlin::


 [[beans-beans-conversion]]
-== ``PropertyEditor``'s
+== Built-in `PropertyEditor` Implementations

 Spring uses the concept of a `PropertyEditor` to effect the conversion between an
 `Object` and a `String`. It can be handy
@@ -249,7 +204,7 @@ behavior can be achieved by registering custom editors of type
 `java.beans.PropertyEditor`. Registering custom editors on a `BeanWrapper` or,
 alternatively, in a specific IoC container (as mentioned in the previous chapter), gives it
 the knowledge of how to convert properties to the desired type. For more about
-`PropertyEditor`, see {java-api}/java.desktop/java/beans/package-summary.html[the javadoc of the `java.beans` package from Oracle].
+`PropertyEditor`, see https://docs.oracle.com/javase/8/docs/api/java/beans/package-summary.html[the javadoc of the `java.beans` package from Oracle].

 A couple of examples where property editing is used in Spring:

@@ -355,7 +310,7 @@ com

 Note that you can also use the standard `BeanInfo` JavaBeans mechanism here as well
 (described to some extent
-{java-tutorial}/javabeans/advanced/customization.html[here]). The
+https://docs.oracle.com/javase/tutorial/javabeans/advanced/customization.html[here]). The
 following example uses the `BeanInfo` mechanism to explicitly register one or more
 `PropertyEditor` instances with the properties of an associated class:

@@ -423,7 +378,7 @@ Kotlin::


 [[beans-beans-conversion-customeditor-registration]]
-=== Custom ``PropertyEditor``'s
+=== Registering Additional Custom `PropertyEditor` Implementations

 When setting bean properties as string values, a Spring IoC container ultimately uses
 standard JavaBeans `PropertyEditor` implementations to convert these strings to the complex type of the
@@ -566,7 +521,7 @@ Finally, the following example shows how to use `CustomEditorConfigurer` to regi
 ----

 [[beans-beans-conversion-customeditor-registration-per]]
-=== `PropertyEditorRegistrar`
+==== Using `PropertyEditorRegistrar`

 Another mechanism for registering property editors with the Spring container is to
 create and use a `PropertyEditorRegistrar`. This interface is particularly useful when
@@ -2,7 +2,7 @@
 = Java Bean Validation

 The Spring Framework provides support for the
-{bean-validation-site}[Java Bean Validation] API.
+https://beanvalidation.org/[Java Bean Validation] API.



@@ -72,7 +72,7 @@ Kotlin::
 ======

 A Bean Validation validator then validates instances of this class based on the declared
-constraints. See {bean-validation-site}[Bean Validation] for general information about
+constraints. See https://beanvalidation.org/[Bean Validation] for general information about
 the API. See the https://hibernate.org/validator/[Hibernate Validator] documentation for
 specific constraints. To learn how to set up a bean validation provider as a Spring
 bean, keep reading.
@@ -123,12 +123,15 @@ Validator, is expected to be present in the classpath and is automatically detec


 [[validation-beanvalidation-spring-inject]]
-=== Inject Jakarta Validator
+=== Injecting a Validator

 `LocalValidatorFactoryBean` implements both `jakarta.validation.ValidatorFactory` and
-`jakarta.validation.Validator`, so you can inject a reference to the latter to
-apply validation logic if you prefer to work with the Bean Validation API directly,
-as the following example shows:
+`jakarta.validation.Validator`, as well as Spring's `org.springframework.validation.Validator`.
+You can inject a reference to either of these interfaces into beans that need to invoke
+validation logic.
+
+You can inject a reference to `jakarta.validation.Validator` if you prefer to work with the Bean
+Validation API directly, as the following example shows:

 [tabs]
 ======
@@ -157,15 +160,8 @@ Kotlin::
 ----
 ======

-
-[[validation-beanvalidation-spring-inject-adapter]]
-=== Inject Spring Validator
-
-In addition to implementing `jakarta.validation.Validator`, `LocalValidatorFactoryBean`
-also adapts to `org.springframework.validation.Validator`, so you can inject a reference
-to the latter if your bean requires the Spring Validation API.
-
-For example:
+You can inject a reference to `org.springframework.validation.Validator` if your bean
+requires the Spring Validation API, as the following example shows:

 [tabs]
 ======
@@ -194,15 +190,9 @@ Kotlin::
 ----
 ======

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

 [[validation-beanvalidation-spring-constraints]]
-=== Configure Custom Constraints
+=== Configuring Custom Constraints

 Each bean validation constraint consists of two parts:

@@ -282,10 +272,11 @@ As the preceding example shows, a `ConstraintValidator` implementation can have


 [[validation-beanvalidation-spring-method]]
-== Spring-driven Method Validation
+=== Spring-driven Method Validation

-You can integrate the method validation feature of Bean Validation into a
-Spring context through a `MethodValidationPostProcessor` bean definition:
+You can integrate the method validation feature supported by Bean Validation 1.1 (and, as
+a custom extension, also by Hibernate Validator 4.3) into a Spring context through a
+`MethodValidationPostProcessor` bean definition:

 [tabs]
 ======
@@ -314,11 +305,11 @@ XML::
 ----
 ======

-To be eligible for Spring-driven method validation, target classes need to be annotated
+To be eligible for Spring-driven method validation, all target classes need to be annotated
 with Spring's `@Validated` annotation, which can optionally also declare the validation
 groups to use. See
-{spring-framework-api}/validation/beanvalidation/MethodValidationPostProcessor.html[`MethodValidationPostProcessor`]
-for setup details with the Hibernate Validator and Bean Validation providers.
+{api-spring-framework}/validation/beanvalidation/MethodValidationPostProcessor.html[`MethodValidationPostProcessor`]
+for setup details with the Hibernate Validator and Bean Validation 1.1 providers.

 [TIP]
 ====
@@ -329,142 +320,8 @@ xref:core/aop/proxying.adoc#aop-understanding-aop-proxies[Understanding AOP Prox
 to always use methods and accessors on proxied classes; direct field access will not work.
 ====

-Spring MVC and WebFlux have built-in support for the same underlying method validation but without
-the need for AOP. Therefore, do check the rest of this section, and also see the Spring MVC
-xref:web/webmvc/mvc-controller/ann-validation.adoc[Validation] and
-xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses] sections, and the WebFlux
-xref:web/webflux/controller/ann-validation.adoc[Validation] and
-xref:web/webflux/ann-rest-exceptions.adoc[Error Responses] sections.


-[[validation-beanvalidation-spring-method-exceptions]]
-=== Method Validation Exceptions
-
-By default, `jakarta.validation.ConstraintViolationException` is raised with the set of
-``ConstraintViolation``s returned by `jakarata.validation.Validator`. As an alternative,
-you can have `MethodValidationException` raised instead with ``ConstraintViolation``s
-adapted to `MessageSourceResolvable` errors. To enable set the following flag:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
-
-	@Configuration
-	public class AppConfig {
-
-		@Bean
-		public MethodValidationPostProcessor validationPostProcessor() {
-			MethodValidationPostProcessor processor = new MethodValidationPostProcessor();
-			processor.setAdaptConstraintViolations(true);
-			return processor;
-		}
-	}
-
----
-
-XML::
-+
-[source,xml,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	<bean class="org.springframework.validation.beanvalidation.MethodValidationPostProcessor">
-		<property name="adaptConstraintViolations" value="true"/>
-	</bean>
----
-======
-
-`MethodValidationException` contains a list of ``ParameterValidationResult``s which
-group errors by method parameter, and each exposes a `MethodParameter`, the argument
-value, and a list of `MessageSourceResolvable` errors adapted from
-``ConstraintViolation``s. For `@Valid` method parameters with cascaded violations on
-fields and properties, the `ParameterValidationResult` is `ParameterErrors` which
-implements `org.springframework.validation.Errors` and exposes validation errors as
-``FieldError``s.
-
-
-[[validation-beanvalidation-spring-method-i18n]]
-=== Customizing Validation Errors
-
-The adapted `MessageSourceResolvable` errors can be turned into error messages to
-display to users through the configured `MessageSource` with locale and language specific
-resource bundles. This section provides an example for illustration.
-
-Given the following class declarations:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	record Person(@Size(min = 1, max = 10) String name) {
-	}
-
-	@Validated
-	public class MyService {
-
-		void addStudent(@Valid Person person, @Max(2) int degrees) {
-			// ...
-		}
-	}
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	@JvmRecord
-	internal data class Person(@Size(min = 1, max = 10) val name: String)
-
-	@Validated
-	class MyService {
-
-		fun addStudent(person: @Valid Person?, degrees: @Max(2) Int) {
-			// ...
-		}
-	}
----
-======
-
-A `ConstraintViolation` on `Person.name()` is adapted to a `FieldErrro` with the following:
-
- Error codes `"Size.student.name"`, `"Size.name"`, `"Size.java.lang.String"`, and `"Size"`
- Message arguments `"name"`, `10`, and `1` (the field name and the constraint attributes)
- Default message "size must be between 1 and 10"
-
-To customize the default message, you can add properties to
-xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
-resource bundles using any of the above errors codes and message arguments. Note also that the
-message argument `"name"` is itself a `MessagreSourceResolvable` with error codes
-`"student.name"` and `"name"` and can customized too. For example:
-
-Properties::
-+
-[source,properties,indent=0,subs="verbatim,quotes",role="secondary"]
----
-Size.student.name=Please, provide a {0} that is between {2} and {1} characters long
-student.name=username
----
-
-A `ConstraintViolation` on the `degrees` method parameter is adapted to a
-`MessageSourceResolvable` with the following:
-
- Error codes `"Max.myService#addStudent.degrees"`, `"Max.degrees"`, `"Max.int"`, `"Max"`
- Message arguments "degrees2 and 2 (the field name and the constraint attribute)
- Default message "must be less than or equal to 2"
-
-To customize the above default message, you can add a property such as:
-
-Properties::
-+
-[source,properties,indent=0,subs="verbatim,quotes",role="secondary"]
----
-Max.degrees=You cannot provide more than {1} {0}
----
-

 [[validation-beanvalidation-spring-other]]
 === Additional Configuration Options
@@ -472,7 +329,7 @@ Max.degrees=You cannot provide more than {1} {0}
 The default `LocalValidatorFactoryBean` configuration suffices for most
 cases. There are a number of configuration options for various Bean Validation
 constructs, from message interpolation to traversal resolution. See the
-{spring-framework-api}/validation/beanvalidation/LocalValidatorFactoryBean.html[`LocalValidatorFactoryBean`]
+{api-spring-framework}/validation/beanvalidation/LocalValidatorFactoryBean.html[`LocalValidatorFactoryBean`]
 javadoc for more information on these options.


@@ -19,8 +19,8 @@ of the field). This is done as a convenience to aid developers when targeting er

 More information on the `MessageCodesResolver` and the default strategy can be found
 in the javadoc of
-{spring-framework-api}/validation/MessageCodesResolver.html[`MessageCodesResolver`] and
-{spring-framework-api}/validation/DefaultMessageCodesResolver.html[`DefaultMessageCodesResolver`],
+{api-spring-framework}/validation/MessageCodesResolver.html[`MessageCodesResolver`] and
+{api-spring-framework}/validation/DefaultMessageCodesResolver.html[`DefaultMessageCodesResolver`],
 respectively.


@@ -268,8 +268,6 @@ Java::
 	@Service
 	public class MyService {

-		private final ConversionService conversionService;
-
 		public MyService(ConversionService conversionService) {
 			this.conversionService = conversionService;
 		}
@@ -139,7 +139,7 @@ Kotlin::
 ======

 The Spring team welcomes community-driven `Formatter` contributions. See
-{spring-framework-issues}[GitHub Issues] to contribute.
+https://github.com/spring-projects/spring-framework/issues[GitHub Issues] to contribute.



@@ -96,7 +96,7 @@ Kotlin::

 The `static` `rejectIfEmpty(..)` method on the `ValidationUtils` class is used to
 reject the `name` property if it is `null` or the empty string. Have a look at the
-{spring-framework-api}/validation/ValidationUtils.html[`ValidationUtils`] javadoc
+{api-spring-framework}/validation/ValidationUtils.html[`ValidationUtils`] javadoc
 to see what functionality it provides besides the example shown previously.

 While it is certainly possible to implement a single `Validator` class to validate each
@@ -193,14 +193,8 @@ Kotlin::
 Validation errors are reported to the `Errors` object passed to the validator. In the case
 of Spring Web MVC, you can use the `<spring:bind/>` tag to inspect the error messages, but
 you can also inspect the `Errors` object yourself. More information about the
-methods it offers can be found in the {spring-framework-api}/validation/Errors.html[javadoc].
-
-Validators may also get locally invoked for the immediate validation of a given object,
-not involving a binding process. As of 6.1, this has been simplified through a new
-`Validator.validateObject(Object)` method which is available by default now, returning
-a simple ´Errors` representation which can be inspected: typically calling `hasErrors()`
-or the new `failOnError` method for turning the error summary message into an exception
-(e.g. `validator.validateObject(myObject).failOnError(IllegalArgumentException::new)`).
+methods it offers can be found in the {api-spring-framework}/validation/Errors.html[javadoc].
+



@@ -151,10 +151,10 @@ Kotlin::
 ----
 ======

-The last example we show here is for typical JDBC support. You could have the `DataSource`
-injected into an initialization method or a constructor, where you would create a `JdbcTemplate`
-and other data access support classes (such as `SimpleJdbcCall` and others) by using this
-`DataSource`. The following example autowires a `DataSource`:
+The last example we show here is for typical JDBC support. You could have the
+`DataSource` injected into an initialization method or a constructor, where you would create a
+`JdbcTemplate` and other data access support classes (such as `SimpleJdbcCall` and others) by using
+this `DataSource`. The following example autowires a `DataSource`:

 [tabs]
 ======
@@ -9,13 +9,13 @@ to the database.
 [[jdbc-batch-classic]]
 == Basic Batch Operations with `JdbcTemplate`

-You accomplish `JdbcTemplate` batch processing by implementing two methods of a special interface,
-`BatchPreparedStatementSetter`, and passing that implementation in as the second parameter
+You accomplish `JdbcTemplate` batch processing by implementing two methods of a special
+interface, `BatchPreparedStatementSetter`, and passing that implementation in as the second parameter
 in your `batchUpdate` method call. You can use the `getBatchSize` method to provide the size of
 the current batch. You can use the `setValues` method to set the values for the parameters of
-the prepared statement. This method is called the number of times that you specified in the
-`getBatchSize` call. The following example updates the `t_actor` table based on entries in a list,
-and the entire list is used as the batch:
+the prepared statement. This method is called the number of times that you
+specified in the `getBatchSize` call. The following example updates the `t_actor` table
+based on entries in a list, and the entire list is used as the batch:

 [tabs]
 ======
@@ -2,26 +2,30 @@
 = Choosing an Approach for JDBC Database Access

 You can choose among several approaches to form the basis for your JDBC database access.
-In addition to three flavors of `JdbcTemplate`, a `SimpleJdbcInsert` and `SimpleJdbcCall`
-approach optimizes database metadata, and the RDBMS Object style results in a more
-object-oriented approach. Once you start using one of these approaches, you can still mix
-and match to include a feature from a different approach.
+In addition to three flavors of `JdbcTemplate`, a new `SimpleJdbcInsert` and
+`SimpleJdbcCall` approach optimizes database metadata, and the RDBMS Object style takes a
+more object-oriented approach similar to that of JDO Query design. Once you start using
+one of these approaches, you can still mix and match to include a feature from a
+different approach. All approaches require a JDBC 2.0-compliant driver, and some
+advanced features require a JDBC 3.0 driver.

 * `JdbcTemplate` is the classic and most popular Spring JDBC approach. This
-  "`lowest-level`" approach and all others use a `JdbcTemplate` under the covers.
+  "`lowest-level`" approach and all others use a JdbcTemplate under the covers.
 * `NamedParameterJdbcTemplate` wraps a `JdbcTemplate` to provide named parameters
  instead of the traditional JDBC `?` placeholders. This approach provides better
  documentation and ease of use when you have multiple parameters for an SQL statement.
 * `SimpleJdbcInsert` and `SimpleJdbcCall` optimize database metadata to limit the amount
-  of necessary configuration. This approach simplifies coding so that you only need to
-  provide the name of the table or procedure and a map of parameters matching the column
-  names. This works only if the database provides adequate metadata. If the database does
-  not provide this metadata, you have to provide explicit configuration of the parameters.
+  of necessary configuration. This approach simplifies coding so that you need to
+  provide only the name of the table or procedure and provide a map of parameters matching
+  the column names. This works only if the database provides adequate metadata. If the
+  database does not provide this metadata, you have to provide explicit
+  configuration of the parameters.
 * RDBMS objects — including `MappingSqlQuery`, `SqlUpdate`, and `StoredProcedure` —
  require you to create reusable and thread-safe objects during initialization of your
-  data-access layer. This approach allows you to define your query string, declare
-  parameters, and compile the query. Once you do that, `execute(...)`, `update(...)`, and
-  `findObject(...)` methods can be called multiple times with various parameter values.
+  data-access layer. This approach is modeled after JDO Query, wherein you define your
+  query string, declare parameters, and compile the query. Once you do that,
+  `execute(...)`, `update(...)`, and `findObject(...)` methods can be called multiple
+  times with various parameter values.



@@ -10,7 +10,7 @@ This section covers:
 * xref:data-access/jdbc/connections.adoc#jdbc-SingleConnectionDataSource[Using `SingleConnectionDataSource`]
 * xref:data-access/jdbc/connections.adoc#jdbc-DriverManagerDataSource[Using `DriverManagerDataSource`]
 * xref:data-access/jdbc/connections.adoc#jdbc-TransactionAwareDataSourceProxy[Using `TransactionAwareDataSourceProxy`]
-* xref:data-access/jdbc/connections.adoc#jdbc-DataSourceTransactionManager[Using `DataSourceTransactionManager` / `JdbcTransactionManager`]
+* xref:data-access/jdbc/connections.adoc#jdbc-DataSourceTransactionManager[Using `DataSourceTransactionManager`]


 [[jdbc-datasource]]
@@ -125,12 +125,8 @@ The following example shows C3P0 configuration:
 == Using `DataSourceUtils`

 The `DataSourceUtils` class is a convenient and powerful helper class that provides
-`static` methods to obtain connections from JNDI and close connections if necessary.
-It supports a thread-bound JDBC `Connection` with `DataSourceTransactionManager` but
-also with `JtaTransactionManager` and `JpaTransactionManager`.
-
-Note that `JdbcTemplate` implies `DataSourceUtils` connection access, using it
-behind every JDBC operation, implicitly participating in an ongoing transaction.
+`static` methods to obtain connections from JNDI and close connections if necessary. It
+supports thread-bound connections with, for example, `DataSourceTransactionManager`.


 [[jdbc-SmartDataSource]]
@@ -169,6 +165,7 @@ In contrast to `DriverManagerDataSource`, it reuses the same connection all the
 avoiding excessive creation of physical connections.


+
 [[jdbc-DriverManagerDataSource]]
 == Using `DriverManagerDataSource`

@@ -199,62 +196,34 @@ participating in Spring managed transactions. It is generally preferable to writ
 own new code by using the higher level abstractions for resource management, such as
 `JdbcTemplate` or `DataSourceUtils`.

-See the {spring-framework-api}/jdbc/datasource/TransactionAwareDataSourceProxy.html[`TransactionAwareDataSourceProxy`]
+See the {api-spring-framework}/jdbc/datasource/TransactionAwareDataSourceProxy.html[`TransactionAwareDataSourceProxy`]
 javadoc for more details.


 [[jdbc-DataSourceTransactionManager]]
-== Using `DataSourceTransactionManager` / `JdbcTransactionManager`
+== Using `DataSourceTransactionManager`

 The `DataSourceTransactionManager` class is a `PlatformTransactionManager`
-implementation for a single JDBC `DataSource`. It binds a JDBC `Connection`
-from the specified `DataSource` to the currently executing thread, potentially
-allowing for one thread-bound `Connection` per `DataSource`.
+implementation for single JDBC data sources. It binds a JDBC connection from the
+specified data source to the currently executing thread, potentially allowing for one
+thread connection per data source.

-Application code is required to retrieve the JDBC `Connection` through
-`DataSourceUtils.getConnection(DataSource)` instead of Java EE's standard
+Application code is required to retrieve the JDBC connection through
+`DataSourceUtils.getConnection(DataSource)` instead of Jakarta EE's standard
 `DataSource.getConnection`. It throws unchecked `org.springframework.dao` exceptions
-instead of checked `SQLExceptions`. All framework classes (such as `JdbcTemplate`) use
-this strategy implicitly. If not used with a transaction manager, the lookup strategy
-behaves exactly like `DataSource.getConnection` and can therefore be used in any case.
+instead of checked `SQLExceptions`. All framework classes (such as `JdbcTemplate`) use this
+strategy implicitly. If not used with this transaction manager, the lookup strategy
+behaves exactly like the common one. Thus, it can be used in any case.

-The `DataSourceTransactionManager` class supports savepoints (`PROPAGATION_NESTED`),
-custom isolation levels, and timeouts that get applied as appropriate JDBC statement
-query timeouts. To support the latter, application code must either use `JdbcTemplate` or
-call the `DataSourceUtils.applyTransactionTimeout(..)` method for each created statement.
+The `DataSourceTransactionManager` class supports custom isolation levels and timeouts
+that get applied as appropriate JDBC statement query timeouts. To support the latter,
+application code must either use `JdbcTemplate` or call the
+`DataSourceUtils.applyTransactionTimeout(..)` method for each created statement.

-You can use `DataSourceTransactionManager` instead of `JtaTransactionManager` in the
-single-resource case, as it does not require the container to support a JTA transaction
-coordinator. Switching between these transaction managers is just a matter of configuration,
-provided you stick to the required connection lookup pattern. Note that JTA does not support
-savepoints or custom isolation levels and has a different timeout mechanism but otherwise
-exposes similar behavior in terms of JDBC resources and JDBC commit/rollback management.
-
-For JTA-style lazy retrieval of actual resource connections, Spring provides a
-corresponding `DataSource` proxy class for the target connection pool: see
-{spring-framework-api}/jdbc/datasource/LazyConnectionDataSourceProxy.html[`LazyConnectionDataSourceProxy`].
-This is particularly useful for potentially empty transactions without actual statement
-execution (never fetching an actual resource in such a scenario), and also in front of
-a routing `DataSource` which means to take the transaction-synchronized read-only flag
-and/or isolation level into account (e.g. `IsolationLevelDataSourceRouter`).
-
-`LazyConnectionDataSourceProxy` also provides special support for a read-only connection
-pool to use during a read-only transaction, avoiding the overhead of switching the JDBC
-Connection's read-only flag at the beginning and end of every transaction when fetching
-it from the primary connection pool (which may be costly depending on the JDBC driver).
-
-NOTE: As of 5.3, Spring provides an extended `JdbcTransactionManager` variant which adds
-exception translation capabilities on commit/rollback (aligned with `JdbcTemplate`).
-Where `DataSourceTransactionManager` will only ever throw `TransactionSystemException`
-(analogous to JTA), `JdbcTransactionManager` translates database locking failures etc to
-corresponding `DataAccessException` subclasses. Note that application code needs to be
-prepared for such exceptions, not exclusively expecting `TransactionSystemException`.
-In scenarios where that is the case, `JdbcTransactionManager` is the recommended choice.
-
-In terms of exception behavior, `JdbcTransactionManager` is roughly equivalent to
-`JpaTransactionManager` and also to `R2dbcTransactionManager`, serving as an immediate
-companion/replacement for each other. `DataSourceTransactionManager` on the other hand
-is equivalent to `JtaTransactionManager` and can serve as a direct replacement there.
+You can use this implementation instead of `JtaTransactionManager` in the single-resource
+case, as it does not require the container to support JTA. Switching between
+both is just a matter of configuration, provided you stick to the required connection lookup
+pattern. JTA does not support custom isolation levels.



@@ -6,7 +6,6 @@ including error handling. It includes the following topics:

 * xref:data-access/jdbc/core.adoc#jdbc-JdbcTemplate[Using `JdbcTemplate`]
 * xref:data-access/jdbc/core.adoc#jdbc-NamedParameterJdbcTemplate[Using `NamedParameterJdbcTemplate`]
-* xref:data-access/jdbc/core.adoc#jdbc-JdbcClient[Unified JDBC Query/Update Operations: `JdbcClient`]
 * xref:data-access/jdbc/core.adoc#jdbc-SQLExceptionTranslator[Using `SQLExceptionTranslator`]
 * xref:data-access/jdbc/core.adoc#jdbc-statements-executing[Running Statements]
 * xref:data-access/jdbc/core.adoc#jdbc-statements-querying[Running Queries]
@@ -51,7 +50,7 @@ corresponding to the fully qualified class name of the template instance (typica

 The following sections provide some examples of `JdbcTemplate` usage. These examples
 are not an exhaustive list of all of the functionality exposed by the `JdbcTemplate`.
-See the attendant {spring-framework-api}/jdbc/core/JdbcTemplate.html[javadoc] for that.
+See the attendant {api-spring-framework}/jdbc/core/JdbcTemplate.html[javadoc] for that.

 [[jdbc-JdbcTemplate-examples-query]]
 === Querying (`SELECT`)
@@ -502,8 +501,8 @@ extend from it, your sub-class inherits a `setDataSource(..)` method from the
 Regardless of which of the above template initialization styles you choose to use (or
 not), it is seldom necessary to create a new instance of a `JdbcTemplate` class each
 time you want to run SQL. Once configured, a `JdbcTemplate` instance is thread-safe.
-If your application accesses multiple databases, you may want multiple `JdbcTemplate`
-instances, which requires multiple `DataSources` and, subsequently, multiple differently
+If your application accesses multiple
+databases, you may want multiple `JdbcTemplate` instances, which requires multiple `DataSources` and, subsequently, multiple differently
 configured `JdbcTemplate` instances.


@@ -532,8 +531,11 @@ Java::
 	}

 	public int countOfActorsByFirstName(String firstName) {
-		String sql = "select count(*) from t_actor where first_name = :first_name";
+
+		String sql = "select count(*) from T_ACTOR where first_name = :first_name";
+
 		SqlParameterSource namedParameters = new MapSqlParameterSource("first_name", firstName);
+
 		return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.class);
 	}
 ----
@@ -545,7 +547,7 @@ Kotlin::
 	private val namedParameterJdbcTemplate = NamedParameterJdbcTemplate(dataSource)

 	fun countOfActorsByFirstName(firstName: String): Int {
-		val sql = "select count(*) from t_actor where first_name = :first_name"
+		val sql = "select count(*) from T_ACTOR where first_name = :first_name"
 		val namedParameters = MapSqlParameterSource("first_name", firstName)
 		return namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Int::class.java)!!
 	}
@@ -577,9 +579,12 @@ Java::
 	}

 	public int countOfActorsByFirstName(String firstName) {
-		String sql = "select count(*) from t_actor where first_name = :first_name";
+
+		String sql = "select count(*) from T_ACTOR where first_name = :first_name";
+
 		Map<String, String> namedParameters = Collections.singletonMap("first_name", firstName);
-		return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.class);
+
+		return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters,  Integer.class);
 	}
 ----

@@ -591,7 +596,7 @@ Kotlin::
 	private val namedParameterJdbcTemplate = NamedParameterJdbcTemplate(dataSource)

 	fun countOfActorsByFirstName(firstName: String): Int {
-		val sql = "select count(*) from t_actor where first_name = :first_name"
+		val sql = "select count(*) from T_ACTOR where first_name = :first_name"
 		val namedParameters = mapOf("first_name" to firstName)
 		return namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Int::class.java)!!
 	}
@@ -639,6 +644,7 @@ Java::
 		}

 		// setters omitted...
+
 	}
 ----

@@ -667,9 +673,12 @@ Java::
 	}

 	public int countOfActors(Actor exampleActor) {
+
 		// notice how the named parameters match the properties of the above 'Actor' class
-		String sql = "select count(*) from t_actor where first_name = :firstName and last_name = :lastName";
+		String sql = "select count(*) from T_ACTOR where first_name = :firstName and last_name = :lastName";
+
 		SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(exampleActor);
+
 		return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.class);
 	}
 ----
@@ -685,7 +694,7 @@ Kotlin::

 	fun countOfActors(exampleActor: Actor): Int {
 		// notice how the named parameters match the properties of the above 'Actor' class
-		val sql = "select count(*) from t_actor where first_name = :firstName and last_name = :lastName"
+		val sql = "select count(*) from T_ACTOR where first_name = :firstName and last_name = :lastName"
 		val namedParameters = BeanPropertySqlParameterSource(exampleActor)
 		return namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Int::class.java)!!
 	}
@@ -698,122 +707,8 @@ functionality that is present only in the `JdbcTemplate` class, you can use the
 `getJdbcOperations()` method to access the wrapped `JdbcTemplate` through the
 `JdbcOperations` interface.

-See also xref:data-access/jdbc/core.adoc#jdbc-JdbcTemplate-idioms[`JdbcTemplate` Best Practices]
-for guidelines on using the `NamedParameterJdbcTemplate` class in the context of an application.
-
-
-[[jdbc-JdbcClient]]
-== Unified JDBC Query/Update Operations: `JdbcClient`
-
-As of 6.1, the named parameter statements of `NamedParameterJdbcTemplate` and the positional
-parameter statements of a regular `JdbcTemplate` are available through a unified client API
-with a fluent interaction model.
-
-For example, with positional parameters:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	private JdbcClient jdbcClient = JdbcClient.create(dataSource);
-
-	public int countOfActorsByFirstName(String firstName) {
-		return this.jdbcClient.sql("select count(*) from t_actor where first_name = ?")
-				.param(firstName);
-				.query(Integer.class).single();
-	}
----
-
-For example, with named parameters:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	private JdbcClient jdbcClient = JdbcClient.create(dataSource);
-
-	public int countOfActorsByFirstName(String firstName) {
-		return this.jdbcClient.sql("select count(*) from t_actor where first_name = :firstName")
-				.param("firstName", firstName);
-				.query(Integer.class).single();
-	}
----
-
-`RowMapper` capabilities are available as well, with flexible result resolution:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	List<Actor> actors = this.jdbcClient.sql("select first_name, last_name from t_actor")
-			.query((rs, rowNum) -> new Actor(rs.getString("first_name"), rs.getString("last_name")))
-			.list();
----
-
-Instead of a custom `RowMapper`, you may also specify a class to map to.
-For example, assuming that `Actor` has `firstName` and `lastName` properties
-as a record class, a custom constructor, bean properties, or plain fields:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	List<Actor> actors = this.jdbcClient.sql("select first_name, last_name from t_actor")
-			.query(Actor.class)
-			.list();
----
-
-With a required single object result:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	Actor actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?",
-			.param(1212L);
-			.query(Actor.class)
-			.single();
----
-
-With a `java.util.Optional` result:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	Optional<Actor> actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?",
-			.param(1212L);
-			.query(Actor.class)
-			.optional();
----
-
-And for an update statement:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (?, ?)")
-			.param("Leonor").param("Watling");
-			.update();
----
-
-Or an update statement with named parameters:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (:firstName, :lastName)")
-			.param("firstName", "Leonor").param("lastName", "Watling");
-			.update();
----
-
-Instead of individual named parameters, you may also specify a parameter source object –
-for example, a record class, a class with bean properties, or a plain field holder which
-provides `firstName` and `lastName` properties, such as the `Actor` class from above:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (:firstName, :lastName)")
-			.paramSource(new Actor("Leonor", "Watling");
-			.update();
----
-
-The automatic `Actor` class mapping for parameters as well as the query results above is
-provided through implicit `SimplePropertySqlParameterSource` and `SimplePropertyRowMapper`
-strategies which are also available for direct use. They can serve as a common replacement
-for `BeanPropertySqlParameterSource` and `BeanPropertyRowMapper`/`DataClassRowMapper`,
-also with `JdbcTemplate` and `NamedParameterJdbcTemplate` themselves.
-
-NOTE: `JdbcClient` is a flexible but simplified facade for JDBC query/update statements.
-Advanced capabilities such as batch inserts and stored procedure calls typically require
-extra customization: consider Spring's `SimpleJdbcInsert` and `SimpleJdbcCall` classes or
-plain direct `JdbcTemplate` usage for any such capabilities not available in `JdbcClient`.
+See also xref:data-access/jdbc/core.adoc#jdbc-JdbcTemplate-idioms[`JdbcTemplate` Best Practices] for guidelines on using the
+`NamedParameterJdbcTemplate` class in the context of an application.


 [[jdbc-SQLExceptionTranslator]]
@@ -823,22 +718,12 @@ plain direct `JdbcTemplate` usage for any such capabilities not available in `Jd
 between ``SQLException``s and Spring's own `org.springframework.dao.DataAccessException`,
 which is agnostic in regard to data access strategy. Implementations can be generic (for
 example, using SQLState codes for JDBC) or proprietary (for example, using Oracle error
-codes) for greater precision. This exception translation mechanism is used behind the
-common `JdbcTemplate` and `JdbcTransactionManager` entry points which do not
-propagate `SQLException` but rather `DataAccessException`.
-
-NOTE: As of 6.0, the default exception translator is `SQLExceptionSubclassTranslator`,
-detecting JDBC 4 `SQLException` subclasses with a few extra checks, and with a fallback
-to `SQLState` introspection through `SQLStateSQLExceptionTranslator`. This is usually
-sufficient for common database access and does not require vendor-specific detection.
-For backwards compatibility, consider using `SQLErrorCodeSQLExceptionTranslator` as
-described below, potentially with custom error code mappings.
+codes) for greater precision.

 `SQLErrorCodeSQLExceptionTranslator` is the implementation of `SQLExceptionTranslator`
-that is used by default when a file named `sql-error-codes.xml` is present in the root
-of the classpath. This implementation uses specific vendor codes. It is more precise than
-`SQLState` or `SQLException` subclass translation. The error code translations are based
-on codes held in a JavaBean type class called `SQLErrorCodes`. This class is created and
+that is used by default. This implementation uses specific vendor codes. It is more
+precise than the `SQLState` implementation. The error code translations are based on
+codes held in a JavaBean type class called `SQLErrorCodes`. This class is created and
 populated by an `SQLErrorCodesFactory`, which (as the name suggests) is a factory for
 creating `SQLErrorCodes` based on the contents of a configuration file named
 `sql-error-codes.xml`. This file is populated with vendor codes and based on the
@@ -859,8 +744,8 @@ The `SQLErrorCodeSQLExceptionTranslator` applies matching rules in the following
  translator. If this translation is not available, the next fallback translator is
  the `SQLStateSQLExceptionTranslator`.

-NOTE: The `SQLErrorCodesFactory` is used by default to define error codes and custom
-exception translations. They are looked up in a file named `sql-error-codes.xml` from the
+NOTE: The `SQLErrorCodesFactory` is used by default to define `Error` codes and custom exception
+translations. They are looked up in a file named `sql-error-codes.xml` from the
 classpath, and the matching `SQLErrorCodes` instance is located based on the database
 name from the database metadata of the database in use.

@@ -899,12 +784,12 @@ Kotlin::
 ----
 ======

-In the preceding example, the specific error code (`-12345`) is translated while
-other errors are left to be translated by the default translator implementation.
-To use this custom translator, you must pass it to the `JdbcTemplate` through the
-method `setExceptionTranslator`, and you must use this `JdbcTemplate` for all of the
-data access processing where this translator is needed. The following example shows
-how you can use this custom translator:
+In the preceding example, the specific error code (`-12345`) is translated, while other errors are
+left to be translated by the default translator implementation. To use this custom
+translator, you must pass it to the `JdbcTemplate` through the method
+`setExceptionTranslator`, and you must use this `JdbcTemplate` for all of the data access
+processing where this translator is needed. The following example shows how you can use this custom
+translator:

 [tabs]
 ======
@@ -915,6 +800,7 @@ Java::
 	private JdbcTemplate jdbcTemplate;

 	public void setDataSource(DataSource dataSource) {
+
 		// create a JdbcTemplate and set data source
 		this.jdbcTemplate = new JdbcTemplate();
 		this.jdbcTemplate.setDataSource(dataSource);
@@ -923,6 +809,7 @@ Java::
 		CustomSQLErrorCodesTranslator tr = new CustomSQLErrorCodesTranslator();
 		tr.setDataSource(dataSource);
 		this.jdbcTemplate.setExceptionTranslator(tr);
+
 	}

 	public void updateShippingCharge(long orderId, long pct) {
@@ -83,7 +83,7 @@ Kotlin::
 ----
 ======

-See the {spring-framework-api}/jdbc/datasource/embedded/EmbeddedDatabaseBuilder.html[javadoc for `EmbeddedDatabaseBuilder`]
+See the {api-spring-framework}/jdbc/datasource/embedded/EmbeddedDatabaseBuilder.html[javadoc for `EmbeddedDatabaseBuilder`]
 for further details on all supported options.

 You can also use the `EmbeddedDatabaseBuilder` to create an embedded database by using Java
@@ -288,7 +288,7 @@ You can extend Spring JDBC embedded database support in two ways:
  connection pool to manage embedded database connections.

 We encourage you to contribute extensions to the Spring community at
-{spring-framework-issues}[GitHub Issues].
+https://github.com/spring-projects/spring-framework/issues[GitHub Issues].



@@ -3,31 +3,30 @@

 The Spring Framework's JDBC abstraction framework consists of four different packages:

-* `core`: The `org.springframework.jdbc.core` package contains the `JdbcTemplate` class
-and its various callback interfaces, plus a variety of related classes. A subpackage
-named `org.springframework.jdbc.core.simple` contains the `SimpleJdbcInsert` and
+* `core`: The `org.springframework.jdbc.core` package contains the `JdbcTemplate` class and its
+various callback interfaces, plus a variety of related classes. A subpackage named
+`org.springframework.jdbc.core.simple` contains the `SimpleJdbcInsert` and
 `SimpleJdbcCall` classes. Another subpackage named
 `org.springframework.jdbc.core.namedparam` contains the `NamedParameterJdbcTemplate`
 class and the related support classes. See xref:data-access/jdbc/core.adoc[Using the JDBC Core Classes to Control Basic JDBC Processing and Error Handling], xref:data-access/jdbc/advanced.adoc[JDBC Batch Operations], and
 xref:data-access/jdbc/simple.adoc[Simplifying JDBC Operations with the `SimpleJdbc` Classes].

-* `datasource`: The `org.springframework.jdbc.datasource` package contains a utility class
-for easy `DataSource` access and various simple `DataSource` implementations that you can
-use for testing and running unmodified JDBC code outside of a Jakarta EE container. A subpackage
-named `org.springframework.jdbc.datasource.embedded` provides support for creating
+* `datasource`: The `org.springframework.jdbc.datasource` package contains a utility class for easy
+`DataSource` access and various simple `DataSource` implementations that you can use for
+testing and running unmodified JDBC code outside of a Jakarta EE container. A subpackage
+named `org.springfamework.jdbc.datasource.embedded` provides support for creating
 embedded databases by using Java database engines, such as HSQL, H2, and Derby. See
 xref:data-access/jdbc/connections.adoc[Controlling Database Connections] and xref:data-access/jdbc/embedded-database-support.adoc[Embedded Database Support].

-* `object`: The `org.springframework.jdbc.object` package contains classes that represent
-RDBMS queries, updates, and stored procedures as thread-safe, reusable objects. See
-xref:data-access/jdbc/object.adoc[Modeling JDBC Operations as Java Objects]. This style
-results in a more object-oriented approach, although objects returned by queries are
-naturally disconnected from the database. This higher-level of JDBC abstraction depends
-on the lower-level abstraction in the `org.springframework.jdbc.core` package.
+* `object`: The `org.springframework.jdbc.object` package contains classes that represent RDBMS
+queries, updates, and stored procedures as thread-safe, reusable objects. See
+xref:data-access/jdbc/object.adoc[Modeling JDBC Operations as Java Objects]. This approach is modeled by JDO, although objects returned by queries
+are naturally disconnected from the database. This higher-level of JDBC abstraction
+depends on the lower-level abstraction in the `org.springframework.jdbc.core` package.

-* `support`: The `org.springframework.jdbc.support` package provides `SQLException`
-translation functionality and some utility classes. Exceptions thrown during JDBC processing
-are translated to exceptions defined in the `org.springframework.dao` package. This means
+* `support`: The `org.springframework.jdbc.support` package provides `SQLException` translation
+functionality and some utility classes. Exceptions thrown during JDBC processing are
+translated to exceptions defined in the `org.springframework.dao` package. This means
 that code using the Spring JDBC abstraction layer does not need to implement JDBC or
 RDBMS-specific error handling. All translated exceptions are unchecked, which gives you
 the option of catching the exceptions from which you can recover while letting other
@@ -121,17 +121,18 @@ Kotlin::
 <3> Using the method `setBlobAsBinaryStream` to pass in the contents of the BLOB.
 ======

+
 [NOTE]
 ====
 If you invoke the `setBlobAsBinaryStream`, `setClobAsAsciiStream`, or
 `setClobAsCharacterStream` method on the `LobCreator` returned from
-`DefaultLobHandler.getLobCreator()`, you can optionally specify a negative value
-for the `contentLength` argument. If the specified content length is negative, the
+`DefaultLobHandler.getLobCreator()`, you can optionally specify a negative value for the
+`contentLength` argument. If the specified content length is negative, the
 `DefaultLobHandler` uses the JDBC 4.0 variants of the set-stream methods without a
 length parameter. Otherwise, it passes the specified length on to the driver.

-See the documentation for the JDBC driver you use to verify that it supports streaming
-a LOB without providing the content length.
+See the documentation for the JDBC driver you use to verify that it supports streaming a
+LOB without providing the content length.
 ====

 Now it is time to read the LOB data from the database. Again, you use a `JdbcTemplate`
@@ -183,15 +184,15 @@ variable list of values. A typical example would be `select * from T_ACTOR where
 JDBC standard. You cannot declare a variable number of placeholders. You need a number
 of variations with the desired number of placeholders prepared, or you need to generate
 the SQL string dynamically once you know how many placeholders are required. The named
-parameter support provided in the `NamedParameterJdbcTemplate` takes the latter approach.
-You can pass in the values as a `java.util.List` (or any `Iterable`) of simple values.
-This list is used to insert the required placeholders into the actual SQL statement
-and pass in the values during statement execution.
+parameter support provided in the `NamedParameterJdbcTemplate` and `JdbcTemplate` takes
+the latter approach. You can pass in the values as a `java.util.List` of primitive objects. This
+list is used to insert the required placeholders and pass in the values during
+statement execution.

-NOTE: Be careful when passing in many values. The JDBC standard does not guarantee that
-you can use more than 100 values for an `IN` expression list. Various databases exceed
-this number, but they usually have a hard limit for how many values are allowed.
-For example, Oracle's limit is 1000.
+NOTE: Be careful when passing in many values. The JDBC standard does not guarantee that you
+can use more than 100 values for an `in` expression list. Various databases exceed this
+number, but they usually have a hard limit for how many values are allowed. For example, Oracle's
+limit is 1000.

 In addition to the primitive values in the value list, you can create a `java.util.List`
 of object arrays. This list can support multiple expressions being defined for the `in`
@@ -407,12 +407,6 @@ exposes the Hibernate transaction as a JDBC transaction if you have set up the p
 `DataSource` for which the transactions are supposed to be exposed through the
 `dataSource` property of the `HibernateTransactionManager` class.

-For JTA-style lazy retrieval of actual resource connections, Spring provides a
-corresponding `DataSource` proxy class for the target connection pool: see
-{spring-framework-api}/jdbc/datasource/LazyConnectionDataSourceProxy.html[`LazyConnectionDataSourceProxy`].
-This is particularly useful for Hibernate read-only transactions which can often
-be processed from a local cache rather than hitting the database.
-

 [[orm-hibernate-resources]]
 == Comparing Container-managed and Locally Defined Resources
@@ -58,8 +58,8 @@ The benefits of using the Spring Framework to create your ORM DAOs include:

 TIP: For more comprehensive ORM support, including support for alternative database
 technologies such as MongoDB, you might want to check out the
-{spring-site-projects}/spring-data/[Spring Data] suite of projects. If you are
-a JPA user, the {spring-site-guides}/gs/accessing-data-jpa/[Getting Started Accessing
+https://projects.spring.io/spring-data/[Spring Data] suite of projects. If you are
+a JPA user, the https://spring.io/guides/gs/accessing-data-jpa/[Getting Started Accessing
 Data with JPA] guide from https://spring.io provides a great introduction.


@@ -88,6 +88,12 @@ You can use this option for full JPA capabilities in a Spring-based application
 This includes web containers such as Tomcat, stand-alone applications, and
 integration tests with sophisticated persistence requirements.

+NOTE: If you want to specifically configure a Hibernate setup, an immediate alternative
+is to set up a native Hibernate `LocalSessionFactoryBean` instead of a plain JPA
+`LocalContainerEntityManagerFactoryBean`, letting it interact with JPA access code
+as well as native Hibernate access code.
+See xref:data-access/orm/jpa.adoc#orm-jpa-hibernate[Native Hibernate setup for JPA interaction] for details.
+
 The `LocalContainerEntityManagerFactoryBean` gives full control over
 `EntityManagerFactory` configuration and is appropriate for environments where
 fine-grained customization is required. The `LocalContainerEntityManagerFactoryBean`
@@ -157,7 +163,7 @@ The `LoadTimeWeaver` interface is a Spring-provided class that lets JPA
 `ClassTransformer` instances be plugged in a specific manner, depending on whether the
 environment is a web container or application server. Hooking `ClassTransformers`
 through an
-{java-api}/java.instrument/java/lang/instrument/package-summary.html[agent]
+https://docs.oracle.com/javase/6/docs/api/java/lang/instrument/package-summary.html[agent]
 is typically not efficient. The agents work against the entire virtual machine and
 inspect every class that is loaded, which is usually undesirable in a production
 server environment.
@@ -181,7 +187,6 @@ and automatic propagation of the weaver to all weaver-aware beans:
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<context:load-time-weaver/>
-
 	<bean id="emf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
 		...
 	</bean>
@@ -276,8 +281,8 @@ Spring Data JPA, make sure to set up deferred bootstrapping for its repositories
 [[orm-jpa-dao]]
 == Implementing DAOs Based on JPA: `EntityManagerFactory` and `EntityManager`

-NOTE: Although `EntityManagerFactory` instances are thread-safe, `EntityManager` instances
-are not. The injected JPA `EntityManager` behaves like an `EntityManager` fetched from an
+NOTE: Although `EntityManagerFactory` instances are thread-safe, `EntityManager` instances are
+not. The injected JPA `EntityManager` behaves like an `EntityManager` fetched from an
 application server's JNDI environment, as defined by the JPA specification. It delegates
 all calls to the current transactional `EntityManager`, if any. Otherwise, it falls back
 to a newly created `EntityManager` per operation, in effect making its usage thread-safe.
@@ -285,8 +290,8 @@ to a newly created `EntityManager` per operation, in effect making its usage thr
 It is possible to write code against the plain JPA without any Spring dependencies, by
 using an injected `EntityManagerFactory` or `EntityManager`. Spring can understand the
 `@PersistenceUnit` and `@PersistenceContext` annotations both at the field and the method level
-if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example shows a plain
-JPA DAO implementation that uses the `@PersistenceUnit` annotation:
+if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example shows a plain JPA DAO implementation
+that uses the `@PersistenceUnit` annotation:

 [tabs]
 ======
@@ -379,9 +384,9 @@ Consider the following example:
 ----

 The main problem with such a DAO is that it always creates a new `EntityManager` through
-the factory. You can avoid this by requesting a transactional `EntityManager` (also called a
-"`shared EntityManager`" because it is a shared, thread-safe proxy for the actual transactional
-EntityManager) to be injected instead of the factory. The following example shows how to do so:
+the factory. You can avoid this by requesting a transactional `EntityManager` (also
+called a "`shared EntityManager`" because it is a shared, thread-safe proxy for the actual
+transactional EntityManager) to be injected instead of the factory. The following example shows how to do so:

 [tabs]
 ======
@@ -420,24 +425,24 @@ Kotlin::
 ----
 ======

-The `@PersistenceContext` annotation has an optional attribute called `type`, which defaults
-to `PersistenceContextType.TRANSACTION`. You can use this default to receive a shared
+The `@PersistenceContext` annotation has an optional attribute called `type`, which defaults to
+`PersistenceContextType.TRANSACTION`. You can use this default to receive a shared
 `EntityManager` proxy. The alternative, `PersistenceContextType.EXTENDED`, is a completely
 different affair. This results in a so-called extended `EntityManager`, which is not
 thread-safe and, hence, must not be used in a concurrently accessed component, such as a
-Spring-managed singleton bean. Extended `EntityManager` instances are only supposed to be used
-in stateful components that, for example, reside in a session, with the lifecycle of the
+Spring-managed singleton bean. Extended `EntityManager` instances are only supposed to be used in
+stateful components that, for example, reside in a session, with the lifecycle of the
 `EntityManager` not tied to a current transaction but rather being completely up to the
 application.

 .Method- and field-level Injection
 ****
-You can apply annotations that indicate dependency injections (such as `@PersistenceUnit`
-and `@PersistenceContext`) on field or methods inside a class -- hence the expressions
-"`method-level injection`" and "`field-level injection`". Field-level annotations are
-concise and easier to use while method-level annotations allow for further processing of the
-injected dependency. In both cases, the member visibility (public, protected, or private)
-does not matter.
+You can apply annotations that indicate dependency injections (such as `@PersistenceUnit` and
+`@PersistenceContext`) on field or methods inside a class -- hence the
+expressions "`method-level injection`" and "`field-level injection`". Field-level
+annotations are concise and easier to use while method-level annotations allow for further
+processing of the injected dependency. In both cases, the member visibility (public,
+protected, or private) does not matter.

 What about class-level annotations?

@@ -446,80 +451,37 @@ injection.
 ****

 The injected `EntityManager` is Spring-managed (aware of the ongoing transaction).
-Even though the new DAO implementation uses method-level injection of an `EntityManager`
-instead of an `EntityManagerFactory`, no change is required in the bean definition
-due to annotation usage.
+Even though the new DAO implementation uses method-level
+injection of an `EntityManager` instead of an `EntityManagerFactory`, no change is
+required in the application context XML, due to annotation usage.

 The main advantage of this DAO style is that it depends only on the Java Persistence API.
 No import of any Spring class is required. Moreover, as the JPA annotations are understood,
 the injections are applied automatically by the Spring container. This is appealing from
 a non-invasiveness perspective and can feel more natural to JPA developers.

-[[orm-jpa-dao-autowired]]
-=== Implementing DAOs Based on `@Autowired` (typically with constructor-based injection)
-
-`@PersistenceUnit` and `@PersistenceContext` can only be declared on methods and fields.
-What about providing JPA resources via constructors and other `@Autowired` injection points?
-
-`EntityManagerFactory` can easily be injected via constructors and `@Autowired` fields/methods
-as long as the target is defined as a bean, e.g. via `LocalContainerEntityManagerFactoryBean`.
-The injection point matches the original `EntityManagerFactory` definition by type as-is.
-
-However, an `@PersistenceContext`-style shared `EntityManager` reference is not available for
-regular dependency injection out of the box. In order to make it available for type-based
-matching as required by `@Autowired`, consider defining a `SharedEntityManagerBean` as a
-companion for your `EntityManagerFactory` definition:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
----
-	<bean id="emf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
-		...
-	</bean>
-
-	<bean id="em" class="org.springframework.orm.jpa.support.SharedEntityManagerBean">
-		<property name="entityManagerFactory" ref="emf"/>
-	</bean>
----
-
-Alternatively, you may define an `@Bean` method based on `SharedEntityManagerCreator`:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	@Bean("em")
-	public static EntityManager sharedEntityManager(EntityManagerFactory emf) {
-		return SharedEntityManagerCreator.createSharedEntityManager(emf);
-	}
----
-
-In case of multiple persistence units, each `EntityManagerFactory` definition needs to be
-accompanied by a corresponding `EntityManager` bean definition, ideally with qualifiers
-that match with the distinct `EntityManagerFactory` definition in order to distinguish
-the persistence units via `@Autowired @Qualifier("...")`.
-

 [[orm-jpa-tx]]
-== Spring-driven JPA Transactions
+== Spring-driven JPA transactions

-NOTE: We strongly encourage you to read xref:data-access/transaction/declarative.adoc[Declarative Transaction Management],
-if you have not already done so, to get more detailed coverage of Spring's declarative transaction support.
+NOTE: We strongly encourage you to read xref:data-access/transaction/declarative.adoc[Declarative Transaction Management], if you have not
+already done so, to get more detailed coverage of Spring's declarative transaction support.

 The recommended strategy for JPA is local transactions through JPA's native transaction
 support. Spring's `JpaTransactionManager` provides many capabilities known from local
 JDBC transactions (such as transaction-specific isolation levels and resource-level
-read-only optimizations) against any regular JDBC connection pool, without requiring
-a JTA transaction coordinator and XA-capable resources.
+read-only optimizations) against any regular JDBC connection pool (no XA requirement).

 Spring JPA also lets a configured `JpaTransactionManager` expose a JPA transaction
 to JDBC access code that accesses the same `DataSource`, provided that the registered
-`JpaDialect` supports retrieval of the underlying JDBC `Connection`. Spring provides
-dialects for the EclipseLink and Hibernate JPA implementations. See the
-xref:data-access/orm/jpa.adoc#orm-jpa-dialect[next section] for details on `JpaDialect`.
+`JpaDialect` supports retrieval of the underlying JDBC `Connection`.
+Spring provides dialects for the EclipseLink and Hibernate JPA implementations.
+See the xref:data-access/orm/jpa.adoc#orm-jpa-dialect[next section] for details on the `JpaDialect` mechanism.

-For JTA-style lazy retrieval of actual resource connections, Spring provides a
-corresponding `DataSource` proxy class for the target connection pool: see
-{spring-framework-api}/jdbc/datasource/LazyConnectionDataSourceProxy.html[`LazyConnectionDataSourceProxy`].
-This is particularly useful for JPA read-only transactions which can often
-be processed from a local cache rather than hitting the database.
+NOTE: As an immediate alternative, Spring's native `HibernateTransactionManager` is capable
+of interacting with JPA access code, adapting to several Hibernate specifics and providing
+JDBC interaction. This makes particular sense in combination with `LocalSessionFactoryBean`
+setup. See xref:data-access/orm/jpa.adoc#orm-jpa-hibernate[Native Hibernate Setup for JPA Interaction] for details.


 [[orm-jpa-dialect]]
@@ -533,7 +495,7 @@ features supported by Spring, usually in a vendor-specific manner:
 * Applying specific transaction semantics (such as custom isolation level or transaction
  timeout)
 * Retrieving the transactional JDBC `Connection` (for exposure to JDBC-based DAOs)
-* Advanced translation of `PersistenceException` to Spring's `DataAccessException`
+* Advanced translation of `PersistenceExceptions` to Spring `DataAccessExceptions`

 This is particularly valuable for special transaction semantics and for advanced
 translation of exception. The default implementation (`DefaultJpaDialect`) does
@@ -548,8 +510,8 @@ way of auto-configuring an `EntityManagerFactory` setup for Hibernate or Eclipse
 respectively. Note that those provider adapters are primarily designed for use with
 Spring-driven transaction management (that is, for use with `JpaTransactionManager`).

-See the {spring-framework-api}/orm/jpa/JpaDialect.html[`JpaDialect`] and
-{spring-framework-api}/orm/jpa/JpaVendorAdapter.html[`JpaVendorAdapter`] javadoc for
+See the {api-spring-framework}/orm/jpa/JpaDialect.html[`JpaDialect`] and
+{api-spring-framework}/orm/jpa/JpaVendorAdapter.html[`JpaVendorAdapter`] javadoc for
 more details of its operations and how they are used within Spring's JPA support.


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