Release v6.0.13

CONTRIBUTING.md

@@ -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/).
+

README.md

@@ -2,7 +2,7 @@
 
 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
 

build.gradle

@@ -1,24 +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.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.1' 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")
 }
 
 configure(allprojects) { project ->
-	apply plugin: "org.springframework.build.localdev"
-	group = "org.springframework"
 	repositories {
 		mavenCentral()
 		maven {
@@ -43,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
@@ -52,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.4"
+		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")
@@ -82,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.39")
 	}
 
 	ext.javadocLinks = [
@@ -93,23 +118,23 @@ configure([rootProject] + javaProjects) { project ->
 			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
 			"https://eclipse.dev/aspectj/doc/released/aspectj5rt-api",
 			"https://www.quartz-scheduler.org/api/2.3.0/",
-			"https://fasterxml.github.io/jackson-core/javadoc/2.14/",
-			"https://fasterxml.github.io/jackson-databind/javadoc/2.14/",
-			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.14/",
+			"https://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[]
 }
 
@@ -119,5 +144,28 @@ configure(moduleProjects) { project ->
 
 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"
+	}
+
 }

buildSrc/build.gradle

@@ -1,6 +1,5 @@
 plugins {
 	id 'java-gradle-plugin'
-	id 'checkstyle'
 }
 
 repositories {
@@ -18,13 +17,10 @@ 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.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
+	implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}")
 	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.3.0"
 	implementation "org.gradle:test-retry-gradle-plugin:1.4.1"
-	implementation "io.spring.javaformat:spring-javaformat-gradle-plugin:${javaFormatVersion}"
-	implementation "io.spring.nohttp:nohttp-gradle:0.0.11"
 }
 
 gradlePlugin {
@@ -37,10 +33,6 @@ gradlePlugin {
 			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"

buildSrc/config/checkstyle/checkstyle.xml

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

buildSrc/gradle.properties

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

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

@@ -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 + "**");
-			}
-		});
-	}
-
-}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -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);
 	}
-
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -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 -> {

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

@@ -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() {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * 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.
@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.springframework.build.api;
 
 import java.io.File;
@@ -132,11 +131,10 @@ public class ApiDiffPlugin implements Plugin<Project> {
 	}
 
 	private File getOutputFile(String baseLineVersion, Project project) {
-		String buildDirectoryPath = project.getRootProject()
-				.getLayout().getBuildDirectory().getAsFile().get().getAbsolutePath();
-		Path outDir = Paths.get(buildDirectoryPath, "reports", "api-diff",
+		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());
 	}
 
-}
+}

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

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

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

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

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

@@ -1,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();
+	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -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));
-			});
 		});
 	}
 }

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

@@ -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> {
 		});
 	}
 
-}
+}

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

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

ci/images/ci-image/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:jammy-20231004
+FROM ubuntu:jammy-20230816
 
 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

ci/images/get-jdk-url.sh

@@ -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/19/GPL/openjdk-22-ea+19_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"

ci/images/setup.sh

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

ci/parameters.yml

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

ci/pipeline.yml

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

ci/scripts/build-pr.sh

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

ci/scripts/build-project.sh

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

ci/scripts/check-project.sh

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

ci/scripts/stage-version.sh

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

ci/tasks/promote-version.yml

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

framework-api/framework-api.gradle

@@ -1,119 +0,0 @@
-plugins {
-	id 'java-platform'
-	id 'io.freefair.aggregate-javadoc' version '8.3'
-}
-
-description = "Spring Framework API Docs"
-
-apply from: "${rootDir}/gradle/publications.gradle"
-
-repositories {
-	maven {
-		url "https://repo.spring.io/release"
-	}
-}
-
-dependencies {
-	moduleProjects.each { moduleProject ->
-		javadoc moduleProject
-	}
-}
-
-javadoc {
-	title = "${rootProject.description} ${version} API"
-	options {
-		encoding = "UTF-8"
-		memberLevel = JavadocMemberLevel.PROTECTED
-		author = true
-		header = rootProject.description
-		use = true
-		overview = "$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
-		}
-	}
-}

framework-docs/framework-docs.gradle

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

framework-docs/modules/ROOT/nav.adoc

@@ -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,7 +414,6 @@
 *** xref:integration/cache/plug.adoc[]
 *** xref:integration/cache/specific-config.adoc[]
 ** xref:integration/observability.adoc[]
-** xref:integration/checkpoint-restore.adoc[]
 ** xref:integration/appendix.adoc[]
 * xref:languages.adoc[]
 ** xref:languages/kotlin.adoc[]

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

@@ -39,6 +39,11 @@ resolvable otherwise. See
 {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].
@@ -55,27 +60,19 @@ for details.
 {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]
+.
 
 |===

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

@@ -728,6 +728,11 @@ 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
   {api-spring-framework}/aop/aspectj/AspectJAdviceParameterNameDiscoverer.html[javadoc]

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

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

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

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

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

@@ -256,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 {api-spring-framework}/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
 

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

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

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

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

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

@@ -478,21 +478,20 @@ 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 {api-spring-framework}/context/event/ApplicationEventMulticaster.html[`ApplicationEventMulticaster`] interface
-and {api-spring-framework}/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, e.g.
+asynchronous event processing by default, 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 which can be applied to a custom
+"applicationEventMulticaster" bean definition.
 
 The following example shows the bean definitions used to register and configure each of
 the classes above:
@@ -748,9 +747,6 @@ Be aware of the following limitations when using asynchronous events:
   value. If you need to publish another event as the result of the processing, inject an
   {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]]

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

@@ -562,9 +562,8 @@ 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.
 
 
 
@@ -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.
 
 
 

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

@@ -372,17 +372,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

framework-docs/modules/ROOT/pages/core/beans/java/basic-concepts.adoc

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

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

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

framework-docs/modules/ROOT/pages/core/expressions/language-ref.adoc

@@ -15,7 +15,7 @@ topics:
 * 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[User-Defined Functions]
+* 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]

framework-docs/modules/ROOT/pages/core/expressions/language-ref/functions.adoc

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

framework-docs/modules/ROOT/pages/core/expressions/language-ref/operator-elvis.adoc

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

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

@@ -1,50 +1,5 @@
-[[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
@@ -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
@@ -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

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

@@ -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
 {api-spring-framework}/validation/beanvalidation/MethodValidationPostProcessor.html[`MethodValidationPostProcessor`]
-for setup details with the Hibernate Validator and Bean Validation providers.
+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

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

@@ -195,12 +195,6 @@ of Spring Web MVC, you can use the `<spring:bind/>` tag to inspect the error mes
 you can also inspect the `Errors` object yourself. More information about the
 methods it offers can be found in the {api-spring-framework}/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)`).
 
 
 

framework-docs/modules/ROOT/pages/data-access/jdbc/choose-style.adoc

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

framework-docs/modules/ROOT/pages/data-access/jdbc/core.adoc

@@ -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]
@@ -702,120 +701,6 @@ See also xref:data-access/jdbc/core.adoc#jdbc-JdbcTemplate-idioms[`JdbcTemplate`
 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`.
-
-
 [[jdbc-SQLExceptionTranslator]]
 == Using `SQLExceptionTranslator`
 
@@ -824,7 +709,7 @@ between ``SQLException``s and Spring's own `org.springframework.dao.DataAccessEx
 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
+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`,

framework-docs/modules/ROOT/pages/data-access/jdbc/packages.adoc

@@ -20,10 +20,9 @@ xref:data-access/jdbc/connections.adoc[Controlling Database Connections] and xre
 
 * `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.
+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

framework-docs/modules/ROOT/pages/data-access/r2dbc.adoc

@@ -254,25 +254,6 @@ Kotlin::
 ----
 ======
 
-Alternatively, there is a shortcut for mapping to a single value:
-
-[source,java]
-----
-	Flux<String> names = client.sql("SELECT name FROM person")
-			.mapValue(String.class)
-			.all();
-----
-
-Or you may map to a result object with bean properties or record components:
-
-[source,java]
-----
-	// assuming a name property on Person
-	Flux<Person> persons = client.sql("SELECT name FROM person")
-			.mapProperties(Person.class)
-			.all();
-----
-
 [[r2dbc-DatabaseClient-mapping-null]]
 .What about `null`?
 ****
@@ -343,27 +324,6 @@ The following example shows parameter binding for a query:
 			.bind("age", 34);
 ----
 
-Alternatively, you may pass in a map of names and values:
-
-[source,java]
-----
-	Map<String, Object> params = new LinkedHashMap<>();
-	params.put("id", "joe");
-	params.put("name", "Joe");
-	params.put("age", 34);
-	db.sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
-			.bindValues(params);
-----
-
-Or you may pass in a parameter object with bean properties or record components:
-
-[source,java]
-----
-	// assuming id, name, age properties on Person
-	db.sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
-			.bindProperties(new Person("joe", "Joe", 34);
-----
-
 .R2DBC Native Bind Markers
 ****
 R2DBC uses database-native bind markers that depend on the actual database vendor.

framework-docs/modules/ROOT/pages/data-access/transaction/declarative/annotations.adoc

@@ -76,7 +76,7 @@ Kotlin::
 
 Used at the class level as above, the annotation indicates a default for all methods of
 the declaring class (as well as its subclasses). Alternatively, each method can be
-annotated individually. See xref:data-access/transaction/declarative/annotations.adoc#transaction-declarative-annotations-method-visibility[method visibility] for
+annotated individually. See xref:data-access/transaction/declarative/annotations.adoc#transaction-declarative-annotations-method-visibility[null] for
 further details on which methods Spring considers transactional. Note that a class-level
 annotation does not apply to ancestor classes up the class hierarchy; in such a scenario,
 inherited methods need to be locally redeclared in order to participate in a

framework-docs/modules/ROOT/pages/data-access/transaction/event.adoc

@@ -57,14 +57,10 @@ attribute of the annotation to `true`.
 
 [NOTE]
 ====
-As of 6.1, `@TransactionalEventListener` can work with thread-bound transactions managed by
-`PlatformTransactionManager` as well as reactive transactions managed by `ReactiveTransactionManager`.
-For the former, listeners are guaranteed to see the current thread-bound transaction.
-Since the latter uses the Reactor context instead of thread-local variables, the transaction
-context needs to be included in the published event instance as the event source.
-See the
-{api-spring-framework}/transaction/reactive/TransactionalEventPublisher.html[`TransactionalEventPublisher`]
-javadoc for details.
+`@TransactionalEventListener` only works with thread-bound transactions managed by
+`PlatformTransactionManager`. A reactive transaction managed by `ReactiveTransactionManager`
+uses the Reactor context instead of thread-local attributes, so from the perspective of
+an event listener, there is no compatible active transaction that it can participate in.
 ====
 
 

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

@@ -16,7 +16,7 @@ STOMP Messaging.
 xref:web-reactive.adoc[Web Reactive] :: Spring WebFlux, WebClient,
 WebSocket, RSocket.
 xref:integration.adoc[Integration] :: REST Clients, JMS, JCA, JMX,
-Email, Tasks, Scheduling, Caching, Observability, JVM Checkpoint Restore.
+Email, Tasks, Scheduling, Caching, Observability.
 xref:languages.adoc[Languages] :: Kotlin, Groovy, Dynamic Languages.
 xref:testing/appendix.adoc[Appendix] :: Spring properties.
 https://github.com/spring-projects/spring-framework/wiki[Wiki] :: What's New,

framework-docs/modules/ROOT/pages/integration/cache/annotations.adoc

@@ -208,76 +208,6 @@ NOTE: This is an optional feature, and your favorite cache library may not suppo
 All `CacheManager` implementations provided by the core framework support it. See the
 documentation of your cache provider for more details.
 
-[[cache-annotations-cacheable-reactive]]
-=== Caching with CompletableFuture and Reactive Return Types
-
-As of 6.1, cache annotations take `CompletableFuture` and reactive return types
-into account, automatically adapting the cache interaction accordingly.
-
-For a method returning a `CompletableFuture`, the object produced by that future
-will be cached whenever it is complete, and the cache lookup for a cache hit will
-be retrieved via a `CompletableFuture`:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Cacheable("books")
-	public CompletableFuture<Book> findBook(ISBN isbn) {...}
-----
-
-For a method returning a Reactor `Mono`, the object emitted by that Reactive Streams
-publisher will be cached whenever it is available, and the cache lookup for a cache
-hit will be retrieved as a `Mono` (backed by a `CompletableFuture`):
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Cacheable("books")
-	public Mono<Book> findBook(ISBN isbn) {...}
-----
-
-For a method returning a Reactor `Flux`, the objects emitted by that Reactive Streams
-publisher will be collected into a `List` and cached whenever that list is complete,
-and the cache lookup for a cache hit will be retrieved as a `Flux` (backed by a
-`CompletableFuture` for the cached `List` value):
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Cacheable("books")
-	public Flux<Book> findBooks(String author) {...}
-----
-
-Such `CompletableFuture` and reactive adaptation also works for synchronized caching,
-computing the value only once in case of a concurrent cache miss:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Cacheable(cacheNames="foos", sync=true) <1>
-	public CompletableFuture<Foo> executeExpensiveOperation(String id) {...}
-----
-<1> Using the `sync` attribute.
-
-NOTE: In order for such an arrangement to work at runtime, the configured cache
-needs to be capable of `CompletableFuture`-based retrieval. The Spring-provided
-`ConcurrentMapCacheManager` automatically adapts to that retrieval style, and
-`CaffeineCacheManager` natively supports it when its asynchronous cache mode is
-enabled: set `setAsyncCacheMode(true)` on your `CaffeineCacheManager` instance.
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Bean
-	CacheManager cacheManager() {
-		CaffeineCacheManager cacheManager = new CaffeineCacheManager();
-		cacheManager.setCacheSpecification(...);
-		cacheManager.setAsyncCacheMode(true);
-		return cacheManager;
-	}
-----
-
-Last but not least, be aware that annotation-driven caching is not appropriate
-for sophisticated reactive interactions involving composition and back pressure.
-If you choose to declare `@Cacheable` on specific reactive methods, consider the
-impact of the rather coarse-granular cache interaction which simply stores the
-emitted object for a `Mono` or even a pre-collected list of objects for a `Flux`.
-
 [[cache-annotations-cacheable-condition]]
 === Conditional Caching
 
@@ -407,9 +337,6 @@ other), such declarations should be avoided. Note also that such conditions shou
 on the result object (that is, the `#result` variable), as these are validated up-front to
 confirm the exclusion.
 
-As of 6.1, `@CachePut` takes `CompletableFuture` and reactive return types into account,
-performing the put operation whenever the produced object is available.
-
 
 [[cache-annotations-evict]]
 == The `@CacheEvict` Annotation
@@ -452,9 +379,6 @@ trigger, the return values are ignored (as they do not interact with the cache).
 not the case with `@Cacheable` which adds data to the cache or updates data in the cache
 and, thus, requires a result.
 
-As of 6.1, `@CacheEvict` takes `CompletableFuture` and reactive return types into account,
-performing an after-invocation evict operation whenever processing has completed.
-
 
 [[cache-annotations-caching]]
 == The `@Caching` Annotation

framework-docs/modules/ROOT/pages/integration/checkpoint-restore.adoc

@@ -1,31 +0,0 @@
-[[checkpoint-restore]]
-= JVM Checkpoint Restore
-
-The Spring Framework integrates with checkpoint/restore as implemented by https://github.com/CRaC/docs[Project CRaC] in order to allow implementing systems capable to reduce the startup and warmup times of Spring-based Java applications with the JVM.
-
-Using this feature requires:
-
-* A checkpoint/restore enabled JVM (Linux only for now).
-* The presence in the classpath of the https://github.com/CRaC/org.crac[`org.crac:crac`] library (version `1.4.0` and above are supported).
-* Specifying the required `java` command line parameters like `-XX:CRaCCheckpointTo=PATH` or `-XX:CRaCRestoreFrom=PATH`.
-
-WARNING: The files generated in the path specified by `-XX:CRaCCheckpointTo=PATH` when a checkpoint is requested contain a representation of the memory of the running JVM, which may contain secrets and other sensitive data. Using this feature should be done with the assumption that any value "seen" by the JVM, such as configuration properties coming from the environment, will be stored in those CRaC files. As a consequence, the security implications of where and how those files are generated, stored and accessed should be carefully assessed.
-
-Conceptually, checkpoint and restore match with xref:core/beans/factory-nature.adoc#beans-factory-lifecycle-processor[Spring `Lifecycle` contract] for individual beans.
-
-== On demand checkpoint/restore of a running application
-
-A checkpoint can be created on demand, for example using a command like `jcmd application.jar JDK.checkpoint`. Before the creation of the checkpoint, Spring Framework
-stops all the running beans, giving them a chance to close resources if needed by implementing `Lifecycle.stop`. After restore, the same beans are restarted, with `Lifecycle.start` allowing to reopen resources when relevant. For libraries not depending on Spring, checkpoint/restore custom integration can be provided by implementing `org.crac.Resource` and registering the related instance.
-
-WARNING: Leveraging checkpoint/restore of a running application typically requires additional lifecycle management to gracefully stop and start using resources like files or sockets and stop active threads.
-
-NOTE: If the checkpoint is created on a warmed-up JVM, the restored JVM will be equally warmed-up, allowing potentially peak performance immediately. This method typically requires access to remote services, and thus requires some level of platform integration.
-
-== Automatic checkpoint/restore at startup
-
-When the `-Dspring.context.checkpoint=onRefresh` Java system property is set, a checkpoint is created automatically during the startup at `LifecycleProcessor.onRefresh` level. At this phase, all non-lazy initialized singletons are instantiated, `InitializingBean.afterPropertiesSet` callbacks have been invoked, but not `Lifecycle.start` ones and `ContextRefreshedEvent` has not yet been published.
-
-WARNING: As mentioned above, and especially in use cases where the CRaC files are shipped as part of a deployable artifact (a container image for example), operate with the assumption that any sensitive data "seen" by the JVM ends up in the CRaC files, and assess carefully the related security implications.
-
-NOTE: Here checkpoint/restore is a way to "fast-forward" the startup of the application to a phase where the application context is about to start, but does not allow to have a fully warmed-up JVM.

framework-docs/modules/ROOT/pages/integration/observability.adoc

@@ -21,20 +21,11 @@ As outlined xref:integration/observability.adoc[at the beginning of this section
 |===
 |Observation name |Description
 
-|xref:integration/observability.adoc#observability.http-client[`"http.client.requests"`]
+|xref:integration/observability.adoc#http-client[`"http.client.requests"`]
 |Time spent for HTTP client exchanges
 
-|xref:integration/observability.adoc#observability.http-server[`"http.server.requests"`]
+|xref:integration/observability.adoc#http-server[`"http.server.requests"`]
 |Processing time for HTTP server exchanges at the Framework level
-
-|xref:integration/observability.adoc#observability.jms.publish[`"jms.message.publish"`]
-|Time spent sending a JMS message to a destination by a message producer.
-
-|xref:integration/observability.adoc#observability.jms.process[`"jms.message.process"`]
-|Processing time for a JMS message that was previously received by a message consumer.
-
-|xref:integration/observability.adoc#observability.tasks-scheduled[`"tasks.scheduled.execution"`]
-|Processing time for an execution of a `@Scheduled` task
 |===
 
 NOTE: Observations are using Micrometer's official naming convention, but Metrics names will be automatically converted
@@ -88,99 +79,6 @@ include-code::./ServerRequestObservationFilter[]
 
 You can configure `ObservationFilter` instances on the `ObservationRegistry`.
 
-[[observability.tasks-scheduled]]
-== @Scheduled tasks instrumentation
-
-An Observation is created for xref:integration/scheduling.adoc#scheduling-enable-annotation-support[each execution of an `@Scheduled` task].
-Applications need to configure the `ObservationRegistry` on the `ScheduledTaskRegistrar` to enable the recording of observations.
-This can be done by declaring a `SchedulingConfigurer` bean that sets the observation registry:
-
-include-code::./ObservationSchedulingConfigurer[]
-
-It is using the `org.springframework.scheduling.support.DefaultScheduledTaskObservationConvention` by default, backed by the `ScheduledTaskObservationContext`.
-You can configure a custom implementation on the `ObservationRegistry` directly.
-During the execution of the scheduled method, the current observation is restored in the `ThreadLocal` context or the Reactor context (if the scheduled method returns a `Mono` or `Flux` type).
-
-By default, the following `KeyValues` are created:
-
-.Low cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`code.function` _(required)_|Name of Java `Method` that is scheduled for execution.
-|`code.namespace` _(required)_|Canonical name of the class of the bean instance that holds the scheduled method.
-|`error` _(required)_|Class name of the exception thrown during the execution, or `"none"` if no exception happened.
-|`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
-|`outcome` _(required)_|Outcome of the method execution. Can be `"SUCCESS"`, `"ERROR"` or `"UNKNOWN"` (if for example the operation was cancelled during execution).
-|===
-
-
-[[observability.jms]]
-== JMS messaging instrumentation
-
-Spring Framework uses the Jakarta JMS instrumentation provided by Micrometer if the `io.micrometer:micrometer-jakarta9` dependency is on the classpath.
-The `io.micrometer.jakarta9.instrument.jms.JmsInstrumentation` instruments `jakarta.jms.Session` and records the relevant observations.
-
-This instrumentation will create 2 types of observations:
-
-* `"jms.message.publish"` when a JMS message is sent to the broker, typically with `JmsTemplate`.
-* `"jms.message.process"` when a JMS message is processed by the application, typically with a `MessageListener` or a `@JmsListener` annotated method.
-
-NOTE: currently there is no instrumentation for `"jms.message.receive"` observations as there is little value in measuring the time spent waiting for the reception of a message.
-Such an integration would typically instrument `MessageConsumer#receive` method calls. But once those return, the processing time is not measured and the trace scope cannot be propagated to the application.
-
-By default, both observations share the same set of possible `KeyValues`:
-
-.Low cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`error` |Class name of the exception thrown during the messaging operation (or "none").
-|`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
-|`messaging.destination.temporary` _(required)_|Whether the destination is a `TemporaryQueue` or `TemporaryTopic` (values: `"true"` or `"false"`).
-|`messaging.operation` _(required)_|Name of JMS operation being performed (values: `"publish"` or `"process"`).
-|===
-
-.High cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`messaging.message.conversation_id` |The correlation ID of the JMS message.
-|`messaging.destination.name` |The name of destination the current message was sent to.
-|`messaging.message.id` |Value used by the messaging system as an identifier for the message.
-|===
-
-[[observability.jms.publish]]
-=== JMS message Publication instrumentation
-
-`"jms.message.publish"` observations are recorded when a JMS message is sent to the broker.
-They measure the time spent sending the message and propagate the tracing information with outgoing JMS message headers.
-
-You will need to configure the `ObservationRegistry` on the `JmsTemplate` to enable observations:
-
-include-code::./JmsTemplatePublish[]
-
-It uses the `io.micrometer.jakarta9.instrument.jms.DefaultJmsPublishObservationConvention` by default, backed by the `io.micrometer.jakarta9.instrument.jms.JmsPublishObservationContext`.
-
-[[observability.jms.process]]
-=== JMS message Processing instrumentation
-
-`"jms.message.process"` observations are recorded when a JMS message is processed by the application.
-They measure the time spent processing the message and propagate the tracing context with incoming JMS message headers.
-
-Most applications will use the xref:integration/jms/annotated.adoc#jms-annotated[`@JmsListener` annotated methods] mechanism to process incoming messages.
-You will need to ensure that the `ObservationRegistry` is configured on the dedicated `JmsListenerContainerFactory`:
-
-include-code::./JmsConfiguration[]
-
-A xref:integration/jms/annotated.adoc#jms-annotated-support[default container factory is required to enable the annotation support],
-but note that `@JmsListener` annotations can refer to specific container factory beans for specific purposes.
-In all cases, Observations are only recorded if the observation registry is configured on the container factory.
-
-Similar observations are recorded with `JmsTemplate` when messages are processed by a `MessageListener`.
-Such listeners are set on a `MessageConsumer` within a session callback (see `JmsTemplate.execute(SessionCallback<T>)`).
-
-This observation uses the `io.micrometer.jakarta9.instrument.jms.DefaultJmsProcessObservationConvention` by default, backed by the `io.micrometer.jakarta9.instrument.jms.JmsProcessObservationContext`.
 
 [[observability.http-server]]
 == HTTP Server instrumentation
@@ -201,7 +99,7 @@ include-code::./UserController[]
 
 NOTE: Because the instrumentation is done at the Servlet Filter level, the observation scope only covers the filters ordered after this one as well as the handling of the request.
 Typically, Servlet container error handling is performed at a lower level and won't have any active observation or span.
-For this use case, a container-specific implementation is required, such as a `org.apache.catalina.Valve` for Tomcat; this is outside the scope of this project.
+For this use case, a container-specific implementation is required, such as a `org.apache.catalina.Valve` for Tomcat; this is outside of the scope of this project.
 
 By default, the following `KeyValues` are created:
 
@@ -209,9 +107,8 @@ By default, the following `KeyValues` are created:
 [cols="a,a"]
 |===
 |Name | Description
-|`error` _(required)_|Class name of the exception thrown during the exchange, or `"none"` if no exception happened.
-|`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
-|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
+|`exception` _(required)_|Name of the exception thrown during the exchange, or `KeyValue#NONE_VALUE`} if no exception happened.
+|`method` _(required)_|Name of HTTP request method or `"none"` if the request was not received properly.
 |`outcome` _(required)_|Outcome of the HTTP server exchange.
 |`status` _(required)_|HTTP response raw status code, or `"UNKNOWN"` if no response was created.
 |`uri` _(required)_|URI pattern for the matching handler if available, falling back to `REDIRECTION` for 3xx responses, `NOT_FOUND` for 404 responses, `root` for requests with no path info, and `UNKNOWN` for all other requests.
@@ -228,15 +125,11 @@ By default, the following `KeyValues` are created:
 [[observability.http-server.reactive]]
 === Reactive applications
 
-Applications need to configure the `WebHttpHandlerBuilder` with a `MeterRegistry` to enable server instrumentation.
-This can be done on the `WebHttpHandlerBuilder`, as follows:
+Applications need to configure the `org.springframework.web.filter.reactive.ServerHttpObservationFilter` reactive `WebFilter` in their application.
+It uses the `org.springframework.http.server.reactive.observation.DefaultServerRequestObservationConvention` by default, backed by the `ServerRequestObservationContext`.
 
-include-code::./HttpHandlerConfiguration[]
-
-It is using the `org.springframework.http.server.reactive.observation.DefaultServerRequestObservationConvention` by default, backed by the `ServerRequestObservationContext`.
-
-This will only record an observation as an error if the `Exception` has not been handled by an application Controller.
-Typically, all exceptions handled by Spring WebFlux's `@ExceptionHandler` and <<web.adoc#webflux-ann-rest-exceptions,`ProblemDetail` support>> will not be recorded with the observation.
+This will only record an observation as an error if the `Exception` has not been handled by the web framework and has bubbled up to the `WebFilter`.
+Typically, all exceptions handled by Spring WebFlux's `@ExceptionHandler` and xref:web/webflux/ann-rest-exceptions.adoc[`ProblemDetail` support] will not be recorded with the observation.
 You can, at any point during request processing, set the error field on the `ObservationContext` yourself:
 
 include-code::./UserController[]
@@ -247,9 +140,8 @@ By default, the following `KeyValues` are created:
 [cols="a,a"]
 |===
 |Name | Description
-|`error` _(required)_|Class name of the exception thrown during the exchange, or `"none"` if no exception happened.
-|`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
-|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
+|`exception` _(required)_|Name of the exception thrown during the exchange, or `"none"` if no exception happened.
+|`method` _(required)_|Name of HTTP request method or `"none"` if the request was not received properly.
 |`outcome` _(required)_|Outcome of the HTTP server exchange.
 |`status` _(required)_|HTTP response raw status code, or `"UNKNOWN"` if no response was created.
 |`uri` _(required)_|URI pattern for the matching handler if available, falling back to `REDIRECTION` for 3xx responses, `NOT_FOUND` for 404 responses, `root` for requests with no path info, and `UNKNOWN` for all other requests.
@@ -278,34 +170,6 @@ Spring Boot will auto-configure `RestTemplateBuilder` beans with the observation
 
 Instrumentation uses the `org.springframework.http.client.observation.ClientRequestObservationConvention` by default, backed by the `ClientRequestObservationContext`.
 
-.Low cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
-|`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. Only the path part of the URI is considered.
-|`client.name` _(required)_|Client name derived from the request URI host.
-|`status` _(required)_|HTTP response raw status code, or `"IO_ERROR"` in case of `IOException`, or `"CLIENT_ERROR"` if no response was received.
-|`outcome` _(required)_|Outcome of the HTTP client exchange.
-|`error` _(required)_|Class name of the exception thrown during the exchange, or `"none"` if no exception happened.
-|`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
-|===
-
-.High cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`http.url` _(required)_|HTTP request URI.
-|===
-
-
-[[observability.http-client.restclient]]
-=== RestClient
-
-Applications must configure an `ObservationRegistry` on the `RestClient.Builder` to enable the instrumentation; without that, observations are "no-ops".
-
-Instrumentation uses the `org.springframework.http.client.observation.ClientRequestObservationConvention` by default, backed by the `ClientRequestObservationContext`.
-
 .Low cardinality Keys
 [cols="a,a"]
 |===
@@ -315,8 +179,7 @@ Instrumentation uses the `org.springframework.http.client.observation.ClientRequ
 |`client.name` _(required)_|Client name derived from the request URI host.
 |`status` _(required)_|HTTP response raw status code, or `"IO_ERROR"` in case of `IOException`, or `"CLIENT_ERROR"` if no response was received.
 |`outcome` _(required)_|Outcome of the HTTP client exchange.
-|`error` _(required)_|Class name of the exception thrown during the exchange, or `"none"` if no exception happened.
-|`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
+|`exception` _(required)_|Name of the exception thrown during the exchange, or `"none"` if no exception happened.
 |===
 
 .High cardinality Keys
@@ -327,6 +190,7 @@ Instrumentation uses the `org.springframework.http.client.observation.ClientRequ
 |===
 
 
+
 [[observability.http-client.webclient]]
 === WebClient
 
@@ -339,13 +203,12 @@ Instrumentation uses the `org.springframework.web.reactive.function.client.Clien
 [cols="a,a"]
 |===
 |Name | Description
-|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
+|`method` _(required)_|Name of HTTP request method or `"none"` if the request could not be created.
 |`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. Only the path part of the URI is considered.
 |`client.name` _(required)_|Client name derived from the request URI host.
 |`status` _(required)_|HTTP response raw status code, or `"IO_ERROR"` in case of `IOException`, or `"CLIENT_ERROR"` if no response was received.
 |`outcome` _(required)_|Outcome of the HTTP client exchange.
-|`error` _(required)_|Class name of the exception thrown during the exchange, or `"none"` if no exception happened.
-|`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
+|`exception` _(required)_|Name of the exception thrown during the exchange, or `"none"` if no exception happened.
 |===
 
 .High cardinality Keys
@@ -356,28 +219,3 @@ Instrumentation uses the `org.springframework.web.reactive.function.client.Clien
 |===
 
 
-[[observability.application-events]]
-== Application Events and `@EventListener`
-
-Spring Framework does not contribute Observations for xref:core/beans/context-introduction.adoc#context-functionality-events-annotation[`@EventListener` calls],
-as they don't have the right semantics for such instrumentation.
-By default, event publication and processing are done synchronously and on the same thread.
-This means that during the execution of that task, the ThreadLocals and logging context will be the same as the event publisher.
-
-If the application globally configures a custom `ApplicationEventMulticaster` with a strategy that schedules event processing on different threads, this is no longer true.
-All `@EventListener` methods will be processed on a different thread, outside the main event publication thread.
-In these cases, the https://micrometer.io/docs/contextPropagation[Micrometer Context Propagation library] can help propagate such values and better correlate the processing of the events.
-The application can configure the chosen `TaskExecutor` to use a `ContextPropagatingTaskDecorator` that decorates tasks and propagates context.
-For this to work, the `io.micrometer:context-propagation` library must be present on the classpath:
-
-include-code::./ApplicationEventsConfiguration[]
-
-Similarly, if that asynchronous choice is made locally for each `@EventListener` annotated method, by adding `@Async` to it,
-you can choose a `TaskExecutor` that propagates context by referring to it by its qualifier.
-Given the following `TaskExecutor` bean definition, configured with the dedicated task decorator:
-
-include-code::./EventAsyncExecutionConfiguration[]
-
-Annotating event listeners with `@Async` and the relevant qualifier will achieve similar context propagation results:
-
-include-code::./EmailNotificationListener[]

framework-docs/modules/ROOT/pages/integration/scheduling.adoc

@@ -66,11 +66,6 @@ The variants that Spring provides are as follows:
   compatible runtime environment (such as a Jakarta EE application server),
   replacing a CommonJ WorkManager for that purpose.
 
-As of 6.1, `ThreadPoolTaskExecutor` provides a pause/resume capability and graceful
-shutdown through Spring's lifecycle management. There is also a new "virtualThreads"
-option on `SimpleAsyncTaskExecutor` which is aligned with JDK 21's Virtual Threads,
-as well as a graceful shutdown capability for `SimpleAsyncTaskExecutor` as well.
-
 
 [[scheduling-task-executor-usage]]
 === Using a `TaskExecutor`
@@ -249,11 +244,6 @@ to provide common bean-style configuration along the lines of `ThreadPoolTaskExe
 These variants work perfectly fine for locally embedded thread pool setups in lenient
 application server environments, as well -- in particular on Tomcat and Jetty.
 
-As of 6.1, `ThreadPoolTaskScheduler` provides a pause/resume capability and graceful
-shutdown through Spring's lifecycle management. There is also a new option called
-`SimpleAsyncTaskScheduler` which is aligned with JDK 21's Virtual Threads, using a
-single scheduler thread but firing up a new thread for every scheduled task execution.
-
 
 
 [[scheduling-annotation-support]]
@@ -363,17 +353,6 @@ the amount of time to wait before the first execution of the method, as the foll
 	}
 ----
 
-For one-time tasks, you can just specify an initial delay by indicating the amount
-of time to wait before the intended execution of the method:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(initialDelay = 1000)
-	public void doSomething() {
-		// something that should run only once
-	}
-----
-
 If simple periodic scheduling is not expressive enough, you can provide a
 xref:integration/scheduling.adoc#scheduling-cron-expression[cron expression].
 The following example runs only on weekdays:
@@ -413,120 +392,6 @@ container and once through the `@Configurable` aspect), with the consequence of
 `@Scheduled` method being invoked twice.
 ====
 
-[[scheduling-annotation-support-scheduled-reactive]]
-=== The `@Scheduled` annotation on Reactive methods or Kotlin suspending functions
-
-As of Spring Framework 6.1, `@Scheduled` methods are also supported on several types
-of reactive methods:
-
- - methods with a `Publisher` return type (or any concrete implementation of `Publisher`)
-like in the following example:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(fixedDelay = 500)
-	public Publisher<Void> reactiveSomething() {
-		// return an instance of Publisher
-	}
-----
-
- - methods with a return type that can be adapted to `Publisher` via the shared instance
-of the `ReactiveAdapterRegistry`, provided the type supports _deferred subscription_ like
-in the following example:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(fixedDelay = 500)
-	public Single<String> rxjavaNonPublisher() {
-		return Single.just("example");
-	}
-----
-
-[NOTE]
-====
-The `CompletableFuture` class is an example of a type that can typically be adapted
-to `Publisher` but doesn't support deferred subscription. Its `ReactiveAdapter` in the
-registry denotes that by having the `getDescriptor().isDeferred()` method return `false`.
-====
-
- - Kotlin suspending functions, like in the following example:
-
-[source,kotlin,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(fixedDelay = 500)
-	suspend fun something() {
-		// do something asynchronous
-	}
-----
-
- - methods that return a Kotlin `Flow` or `Deferred` instance, like in the following example:
-
-[source,kotlin,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(fixedDelay = 500)
-	fun something(): Flow<Void> {
-		flow {
-			// do something asynchronous
-		}
-	}
-----
-
-All these types of methods must be declared without any arguments. In the case of Kotlin
-suspending functions, the `kotlinx.coroutines.reactor` bridge must also be present to allow
-the framework to invoke a suspending function as a `Publisher`.
-
-The Spring Framework will obtain a `Publisher` for the annotated method once and will
-schedule a `Runnable` in which it subscribes to said `Publisher`. These inner regular
-subscriptions occur according to the corresponding `cron`/fixedDelay`/`fixedRate` configuration.
-
-If the `Publisher` emits `onNext` signal(s), these are ignored and discarded (the same way
-return values from synchronous `@Scheduled` methods are ignored).
-
-In the following example, the `Flux` emits `onNext("Hello"), onNext("World")` every 5
-seconds, but these values are unused:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(initialDelay = 5000, fixedRate = 5000)
-	public Flux<String> reactiveSomething() {
-		return Flux.just("Hello", "World");
-	}
-----
-
-If the `Publisher` emits an `onError` signal, it is logged at `WARN` level and recovered.
-Because of the asynchronous and lazy nature of `Publisher` instances, exceptions are
-not thrown from the `Runnable` task: this means that the `ErrorHandler` contract is not
-involved for reactive methods.
-
-As a result, further scheduled subscription occurs despite the error.
-
-In the following example, the `Mono` subscription fails twice in the first five seconds.
-Then subscriptions start succeeding, printing a message to the standard output every five
-seconds:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(initialDelay = 0, fixedRate = 5000)
-	public Mono<Void> reactiveSomething() {
-		AtomicInteger countdown = new AtomicInteger(2);
-
-		return Mono.defer(() -> {
-			if (countDown.get() == 0 || countDown.decrementAndGet() == 0) {
-				return Mono.fromRunnable(() -> System.out.println("Message"));
-			}
-			return Mono.error(new IllegalStateException("Cannot deliver message"));
-		})
-	}
-----
-
-[NOTE]
-====
-When destroying the annotated bean or closing the application context, Spring Framework cancels
-scheduled tasks, which includes the next scheduled subscription to the `Publisher` as well
-as any past subscription that is still currently active (e.g. for long-running publishers
-or even infinite publishers).
-====
-
 
 [[scheduling-annotation-support-async]]
 === The `@Async` annotation

framework-docs/modules/ROOT/pages/languages/kotlin/spring-projects-in.adoc

@@ -248,7 +248,7 @@ For example, declaring `List<Foo>` in Kotlin is conceptually equivalent to `java
 `kotlin.collections.List` is declared as
 https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/[`interface List<out E> : kotlin.collections.Collection<E>`].
 
-This needs to be taken into account by using the `out` Kotlin keyword on generic types when using Java classes,
+This needs to be taken in account by using the `out` Kotlin keyword on generic types when using Java classes,
 for example when writing a `org.springframework.core.convert.converter.Converter` from a Kotlin type to a Java type.
 
 [source,kotlin,indent=0]
@@ -287,14 +287,11 @@ https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-featu
 === Constructor injection
 
 As described in the xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-di[dedicated section],
-JUnit Jupiter (JUnit 5) allows constructor injection of beans which is pretty useful with Kotlin
+JUnit 5 allows constructor injection of beans which is pretty useful with Kotlin
 in order to use `val` instead of `lateinit var`. You can use
 {api-spring-framework}/test/context/TestConstructor.html[`@TestConstructor(autowireMode = AutowireMode.ALL)`]
 to enable autowiring for all parameters.
 
-NOTE: You can also change the default behavior to `ALL` in a `junit-platform.properties`
-file with a `spring.test.constructor.autowire.mode = all` property.
-
 [source,kotlin,indent=0]
 ----
 @SpringJUnitConfig(TestConfig::class)
@@ -311,11 +308,11 @@ class OrderServiceIntegrationTests(val orderService: OrderService,
 === `PER_CLASS` Lifecycle
 
 Kotlin lets you specify meaningful test function names between backticks (```).
-With JUnit Jupiter (JUnit 5), Kotlin test classes can use the `@TestInstance(TestInstance.Lifecycle.PER_CLASS)`
+As of JUnit 5, Kotlin test classes can use the `@TestInstance(TestInstance.Lifecycle.PER_CLASS)`
 annotation to enable single instantiation of test classes, which allows the use of `@BeforeAll`
 and `@AfterAll` annotations on non-static methods, which is a good fit for Kotlin.
 
-NOTE: You can also change the default behavior to `PER_CLASS` in a `junit-platform.properties`
+You can also change the default behavior to `PER_CLASS` thanks to a `junit-platform.properties`
 file with a `junit.jupiter.testinstance.lifecycle.default = per_class` property.
 
 The following example demonstrates `@BeforeAll` and `@AfterAll` annotations on non-static methods:

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

@@ -137,12 +137,10 @@ demonstrate its API and protocol features.
 
 The `spring-messaging` module contains the following:
 
-* xref:rsocket.adoc#rsocket-requester[RSocketRequester] -- fluent API to make requests
-through an `io.rsocket.RSocket` with data and metadata encoding/decoding.
-* xref:rsocket.adoc#rsocket-annot-responders[Annotated Responders] -- `@MessageMapping`
-  and `@RSocketExchange` annotated handler methods for responding.
-* xref:rsocket.adoc#rsocket-interface[RSocket Interface] -- RSocket service declaration
-as Java interface with `@RSocketExchange` methods, for use as requester or responder.
+* xref:rsocket.adoc#rsocket-requester[RSocketRequester] -- fluent API to make requests through an `io.rsocket.RSocket`
+  with data and metadata encoding/decoding.
+* xref:rsocket.adoc#rsocket-annot-responders[Annotated Responders] -- `@MessageMapping` annotated handler methods for
+  responding.
 
 The `spring-web` module contains `Encoder` and `Decoder` implementations such as Jackson
 CBOR/JSON, and Protobuf that RSocket applications will likely need. It also contains the
@@ -865,69 +863,6 @@ interaction type(s):
 
 
 
-[[rsocket-annot-rsocketexchange]]
-=== @RSocketExchange
-
-As an alternative to  `@MessageMapping`, you can also handle requests with
-`@RSocketExchange` methods. Such methods are declared on an
-xref:rsocket-interface[RSocket Interface] and can be used as a requester via
-`RSocketServiceProxyFactory` or implemented by a responder.
-
-For example, to handle requests as a responder:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public interface RadarsService {
-
-		@RSocketExchange("locate.radars.within")
-		Flux<AirportLocation> radars(MapRequest request);
-	}
-
-	@Controller
-	public class RadarsController implements RadarsService {
-
-		public Flux<AirportLocation> radars(MapRequest request) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	interface RadarsService {
-
-		@RSocketExchange("locate.radars.within")
-		fun radars(request: MapRequest): Flow<AirportLocation>
-	}
-
-	@Controller
-	class RadarsController : RadarsService {
-
-		override fun radars(request: MapRequest): Flow<AirportLocation> {
-			// ...
-		}
-	}
-----
-======
-
-There some differences between `@RSocketExhange` and `@MessageMapping` since the
-former needs to remain suitable for requester and responder use. For example, while
-`@MessageMapping` can be declared to handle any number of routes and each route can
-be a pattern, `@RSocketExchange` must be declared with a single, concrete route. There are
-also small differences in the supported method parameters related to metadata, see
-xref:rsocket-annot-messagemapping[@MessageMapping] and
-xref:rsocket-interface[RSocket Interface] for a list of supported parameters.
-
-`@RSocketExchange` can be used at the type level to specify a common prefix for all routes
-for a given RSocket service interface.
-
-
 [[rsocket-annot-connectmapping]]
 === @ConnectMapping
 
@@ -1062,13 +997,12 @@ Kotlin::
 [[rsocket-interface]]
 == RSocket Interface
 
-The Spring Framework lets you define an RSocket service as a Java interface with
-`@RSocketExchange` methods. You can pass such an interface to `RSocketServiceProxyFactory`
-to create a proxy which performs requests through an
-xref:rsocket.adoc#rsocket-requester[RSocketRequester]. You can also implement the
-interface as a responder that handles requests.
+The Spring Framework lets you define an RSocket service as a Java interface with annotated
+methods for RSocket exchanges. You can then generate a proxy that implements this interface
+and performs the exchanges. This helps to simplify RSocket remote access by wrapping the
+use of the underlying xref:rsocket.adoc#rsocket-requester[RSocketRequester].
 
-Start by creating the interface with `@RSocketExchange` methods:
+One, declare an interface with `@RSocketExchange` methods:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -1082,7 +1016,7 @@ Start by creating the interface with `@RSocketExchange` methods:
 	}
 ----
 
-Now you can create a proxy that performs requests when methods are called:
+Two, create a proxy that will perform the declared RSocket exchanges:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -1092,10 +1026,6 @@ Now you can create a proxy that performs requests when methods are called:
 	RadarService service = factory.createClient(RadarService.class);
 ----
 
-You can also implement the interface to handle requests as a responder.
-See xref:rsocket.adoc#rsocket-annot-rsocketexchange[Annotated Responders].
-
-
 
 [[rsocket-interface-method-parameters]]
 === Method Parameters
@@ -1136,10 +1066,3 @@ method parameters:
 Annotated, RSocket exchange methods support return values that are concrete value(s), or
 any producer of value(s) that can be adapted to a Reactive Streams `Publisher` via
 `ReactiveAdapterRegistry`.
-
-By default, the behavior of RSocket service methods with synchronous (blocking) method
-signature depends on response timeout settings of the underlying RSocket `ClientTransport`
-as well as RSocket keep-alive settings. `RSocketServiceProxyFactory.Builder` does expose a
-`blockTimeout` option that also lets you configure the maximum time to block for a response,
-but we recommend configuring timeout values at the RSocket level for more control.
-

framework-docs/modules/ROOT/pages/testing/annotations/integration-junit-jupiter.adoc

@@ -11,7 +11,6 @@ xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupite
 * xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-nestedtestconfiguration[`@NestedTestConfiguration`]
 * xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-junit-jupiter-enabledif[`@EnabledIf`]
 * xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-junit-jupiter-disabledif[`@DisabledIf`]
-* xref:testing/annotations/integration-spring/annotation-disabledinaotmode.adoc[`@DisabledInAotMode`]
 
 [[integration-testing-annotations-junit-jupiter-springjunitconfig]]
 == `@SpringJUnitConfig`
@@ -171,9 +170,8 @@ of a test class constructor are autowired from components in the test's
 
 If `@TestConstructor` is not present or meta-present on a test class, the default _test
 constructor autowire mode_ will be used. See the tip below for details on how to change
-the default mode. Note, however, that a local declaration of `@Autowired`,
-`@jakarta.inject.Inject`, or `@javax.inject.Inject` on a constructor takes precedence
-over both `@TestConstructor` and the default mode.
+the default mode. Note, however, that a local declaration of `@Autowired` on a
+constructor takes precedence over both `@TestConstructor` and the default mode.
 
 .Changing the default test constructor autowire mode
 [TIP]
@@ -224,7 +222,6 @@ following annotations.
 * xref:testing/annotations/integration-spring/annotation-contextconfiguration.adoc[`@ContextConfiguration`]
 * xref:testing/annotations/integration-spring/annotation-webappconfiguration.adoc[`@WebAppConfiguration`]
 * xref:testing/annotations/integration-spring/annotation-contexthierarchy.adoc[`@ContextHierarchy`]
-* xref:testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc[`@ContextCustomizerFactories`]
 * xref:testing/annotations/integration-spring/annotation-activeprofiles.adoc[`@ActiveProfiles`]
 * xref:testing/annotations/integration-spring/annotation-testpropertysource.adoc[`@TestPropertySource`]
 * xref:testing/annotations/integration-spring/annotation-dynamicpropertysource.adoc[`@DynamicPropertySource`]

framework-docs/modules/ROOT/pages/testing/annotations/integration-meta.adoc

@@ -11,7 +11,6 @@ xref:testing/testcontext-framework.adoc[TestContext framework].
 * `@BootstrapWith`
 * `@ContextConfiguration`
 * `@ContextHierarchy`
-* `@ContextCustomizerFactories`
 * `@ActiveProfiles`
 * `@TestPropertySource`
 * `@DirtiesContext`

framework-docs/modules/ROOT/pages/testing/annotations/integration-spring.adoc

@@ -12,7 +12,6 @@ Spring's testing annotations include the following:
 * xref:testing/annotations/integration-spring/annotation-contextconfiguration.adoc[`@ContextConfiguration`]
 * xref:testing/annotations/integration-spring/annotation-webappconfiguration.adoc[`@WebAppConfiguration`]
 * xref:testing/annotations/integration-spring/annotation-contexthierarchy.adoc[`@ContextHierarchy`]
-* xref:testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc[`@ContextCustomizerFactories`]
 * xref:testing/annotations/integration-spring/annotation-activeprofiles.adoc[`@ActiveProfiles`]
 * xref:testing/annotations/integration-spring/annotation-testpropertysource.adoc[`@TestPropertySource`]
 * xref:testing/annotations/integration-spring/annotation-dynamicpropertysource.adoc[`@DynamicPropertySource`]
@@ -27,5 +26,4 @@ Spring's testing annotations include the following:
 * xref:testing/annotations/integration-spring/annotation-sqlconfig.adoc[`@SqlConfig`]
 * xref:testing/annotations/integration-spring/annotation-sqlmergemode.adoc[`@SqlMergeMode`]
 * xref:testing/annotations/integration-spring/annotation-sqlgroup.adoc[`@SqlGroup`]
-* xref:testing/annotations/integration-spring/annotation-disabledinaotmode.adoc[`@DisabledInAotMode`]
 

framework-docs/modules/ROOT/pages/testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc

@@ -1,45 +0,0 @@
-[[spring-testing-annotation-contextcustomizerfactories]]
-= `@ContextCustomizerFactories`
-
-`@ContextCustomizerFactories` is used to register `ContextCustomizerFactory`
-implementations for a particular test class, its subclasses, and its nested classes. If
-you wish to register a factory globally, you should register it via the automatic
-discovery mechanism described in
-xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[`ContextCustomizerFactory` Configuration].
-
-The following example shows how to register two `ContextCustomizerFactory` implementations:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@ContextConfiguration
-	@ContextCustomizerFactories({CustomContextCustomizerFactory.class, AnotherContextCustomizerFactory.class}) // <1>
-	class CustomContextCustomizerFactoryTests {
-		// class body...
-	}
-----
-<1> Register two `ContextCustomizerFactory` implementations.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@ContextConfiguration
-	@ContextCustomizerFactories([CustomContextCustomizerFactory::class, AnotherContextCustomizerFactory::class]) // <1>
-	class CustomContextCustomizerFactoryTests {
-		// class body...
-	}
-----
-<1> Register two `ContextCustomizerFactory` implementations.
-======
-
-
-By default, `@ContextCustomizerFactories` provides support for inheriting factories from
-superclasses or enclosing classes. See
-xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-nested-test-configuration[`@Nested` test class configuration] and the
-{api-spring-framework}/test/context/ContextCustomizerFactories.html[`@ContextCustomizerFactories`
-javadoc] for an example and further details.
-

framework-docs/modules/ROOT/pages/testing/annotations/integration-spring/annotation-disabledinaotmode.adoc

@@ -1,20 +0,0 @@
-[[spring-testing-annotation-disabledinaotmode]]
-= `@DisabledInAotMode`
-
-`@DisabledInAotMode` signals that an annotated test class is disabled in Spring AOT
-(ahead-of-time) mode, which means that the `ApplicationContext` for the test class will
-not be processed for AOT optimizations at build time.
-
-If a test class is annotated with `@DisabledInAotMode`, all other test classes which
-specify configuration to load the same `ApplicationContext` must also be annotated with
-`@DisabledInAotMode`. Failure to annotate all such test classes will result in an
-exception, either at build time or run time.
-
-When used with JUnit Jupiter based tests, `@DisabledInAotMode` also signals that the
-annotated test class or test method is disabled when running the test suite in Spring AOT
-mode. When applied at the class level, all test methods within that class will be
-disabled. In this sense, `@DisabledInAotMode` has semantics similar to those of JUnit
-Jupiter's `@DisabledInNativeImage` annotation.
-
-For details on AOT support specific to integration tests, see
-xref:testing/testcontext-framework/aot.adoc[Ahead of Time Support for Tests].

framework-docs/modules/ROOT/pages/testing/testcontext-framework/aot.adoc

@@ -19,31 +19,7 @@ following features.
   use an AOT-optimized `ApplicationContext` that participates transparently with the
   xref:testing/testcontext-framework/ctx-management/caching.adoc[context cache].
 
-All tests are enabled in AOT mode by default. However, you can selectively disable an
-entire test class or individual test method in AOT mode by annotating it with
-xref:testing/annotations/integration-spring/annotation-disabledinaotmode.adoc[`@DisabledInAotMode`].
-When using JUnit Jupiter, you may selectively enable or disable tests in a GraalVM native
-image via Jupiter's `@EnabledInNativeImage` and `@DisabledInNativeImage` annotations.
-Note that `@DisabledInAotMode` also disables the annotated test class or test method when
-running within a GraalVM native image, analogous to JUnit Jupiter's
-`@DisabledInNativeImage` annotation.
-
-[TIP]
-====
-By default, if an error is encountered during build-time AOT processing, an exception
-will be thrown, and the overall process will fail immediately.
-
-If you would prefer that build-time AOT processing continue after errors are encountered,
-you can disable the `failOnError` mode which results in errors being logged at `WARN`
-level or with greater detail at `DEBUG` level.
-
-The `failOnError` mode can be disabled from the command line or a build script by setting
-a JVM system property named `spring.test.aot.processing.failOnError` to `false`. As an
-alternative, you can set the same property via the
-xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
-====
-
-[NOTE]
+[WARNING]
 ====
 The `@ContextHierarchy` annotation is currently not supported in AOT mode.
 ====

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management.adoc

@@ -112,7 +112,6 @@ advanced use cases.
 * xref:testing/testcontext-framework/ctx-management/groovy.adoc[Context Configuration with Groovy Scripts]
 * xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[Context Configuration with Component Classes]
 * xref:testing/testcontext-framework/ctx-management/mixed-config.adoc[Mixing XML, Groovy Scripts, and Component Classes]
-* xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[Context Configuration with Context Customizers]
 * xref:testing/testcontext-framework/ctx-management/initializers.adoc[Context Configuration with Context Initializers]
 * xref:testing/testcontext-framework/ctx-management/inheritance.adoc[Context Configuration Inheritance]
 * xref:testing/testcontext-framework/ctx-management/env-profiles.adoc[Context Configuration with Environment Profiles]
@@ -120,6 +119,5 @@ advanced use cases.
 * xref:testing/testcontext-framework/ctx-management/dynamic-property-sources.adoc[Context Configuration with Dynamic Property Sources]
 * xref:testing/testcontext-framework/ctx-management/web.adoc[Loading a `WebApplicationContext`]
 * xref:testing/testcontext-framework/ctx-management/caching.adoc[Context Caching]
-* xref:testing/testcontext-framework/ctx-management/failure-threshold.adoc[Context Failure Threshold]
 * xref:testing/testcontext-framework/ctx-management/hierarchies.adoc[Context Hierarchies]
 

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/caching.adoc

@@ -20,7 +20,7 @@ framework uses the following configuration parameters to build the context cache
 * `contextLoader` (from `@ContextConfiguration`)
 * `parent` (from `@ContextHierarchy`)
 * `activeProfiles` (from `@ActiveProfiles`)
-* `propertySourceDescriptors` (from `@TestPropertySource`)
+* `propertySourceLocations` (from `@TestPropertySource`)
 * `propertySourceProperties` (from `@TestPropertySource`)
 * `resourceBasePath` (from `@WebAppConfiguration`)
 

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/context-customizers.adoc

@@ -1,69 +0,0 @@
-[[testcontext-context-customizers]]
-= Configuration Configuration with Context Customizers
-
-A `ContextCustomizer` is responsible for customizing the supplied
-`ConfigurableApplicationContext` after bean definitions have been loaded into the context
-but before the context has been refreshed.
-
-A `ContextCustomizerFactory` is responsible for creating a `ContextCustomizer`, based on
-some custom logic which determines if the `ContextCustomizer` is necessary for a given
-test class -- for example, based on the presence of a certain annotation. Factories are
-invoked after `ContextLoaders` have processed context configuration attributes for a test
-class but before the `MergedContextConfiguration` is created.
-
-For example, Spring Framework provides the following `ContextCustomizerFactory`
-implementation which is registered by default:
-
-`MockServerContainerContextCustomizerFactory`:: Creates a
-  `MockServerContainerContextCustomizer` if WebSocket support is present in the classpath
-  and the test class or one of its enclosing classes is annotated or meta-annotated with
-  `@WebAppConfiguration`. `MockServerContainerContextCustomizer` instantiates a new
-  `MockServerContainer` and stores it in the `ServletContext` under the attribute named
-  `jakarta.websocket.server.ServerContainer`.
-
-
-[[testcontext-context-customizers-registration]]
-== Registering `ContextCustomizerFactory` Implementations
-
-You can register `ContextCustomizerFactory` implementations explicitly for a test class, its
-subclasses, and its nested classes by using the `@ContextCustomizerFactories` annotation. See
-xref:testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc[annotation support]
-and the javadoc for
-{api-spring-framework}/test/context/ContextCustomizerFactories.html[`@ContextCustomizerFactories`]
-for details and examples.
-
-
-[[testcontext-context-customizers-automatic-discovery]]
-== Automatic Discovery of Default `ContextCustomizerFactory` Implementations
-
-Registering `ContextCustomizerFactory` implementations by using `@ContextCustomizerFactories` is
-suitable for custom factories that are used in limited testing scenarios. However, it can
-become cumbersome if a custom factory needs to be used across an entire test suite. This
-issue is addressed through support for automatic discovery of default
-`ContextCustomizerFactory` implementations through the `SpringFactoriesLoader` mechanism.
-
-Specifically, the modules that make up the testing support in Spring Framework and Spring
-Boot declare all core default `ContextCustomizerFactory` implementations under the
-`org.springframework.test.context.ContextCustomizerFactory` key in their
-`META-INF/spring.factories` properties files. Third-party frameworks and developers can
-contribute their own `ContextCustomizerFactory` implementations to the list of default
-factories in the same manner through their own `META-INF/spring.factories` properties
-files.
-
-
-[[testcontext-context-customizers-merging]]
-== Merging `ContextCustomizerFactory` Implementations
-
-If a custom `ContextCustomizerFactory` is registered via `@ContextCustomizerFactories`, it
-will be _merged_ with the default factories that have been registered using the aforementioned
-xref:testing/testcontext-framework/ctx-management/context-customizers.adoc#testcontext-context-customizers-automatic-discovery[automatic discovery mechanism].
-
-The merging algorithm ensures that duplicates are removed from the list and that locally
-declared factories are appended to the list of default factories when merged.
-
-[TIP]
-====
-To replace the default factories for a test class, its subclasses, and its nested
-classes, you can set the `mergeMode` attribute of `@ContextCustomizerFactories` to
-`MergeMode.REPLACE_DEFAULTS`.
-====

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/failure-threshold.adoc

@@ -1,23 +0,0 @@
-[[testcontext-ctx-management-failure-threshold]]
-= Context Failure Threshold
-
-As of Spring Framework 6.1, a context _failure threshold_ policy is in place which helps
-avoid repeated attempts to load a failing `ApplicationContext`. By default, the failure
-threshold is set to `1` which means that only one attempt will be made to load an
-`ApplicationContext` for a given context cache key (see
-xref:testing/testcontext-framework/ctx-management/caching.adoc[Context Caching]). Any
-subsequent attempt to load the `ApplicationContext` for the same context cache key will
-result in an immediate `IllegalStateException` with an error message which explains that
-the attempt was preemptively skipped. This behavior allows individual test classes and
-test suites to fail faster by avoiding repeated attempts to load an `ApplicationContext`
-that will never successfully load -- for example, due to a configuration error or a missing
-external resource that prevents the context from loading in the current environment.
-
-You can configure the context failure threshold from the command line or a build script
-by setting a JVM system property named `spring.test.context.failure.threshold` with a
-positive integer value. As an alternative, you can set the same property via the
-xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
-
-NOTE: If you wish to effectively disable the context failure threshold, you can set the
-property to a very large value. For example, from the command line you could set the
-system property via `-Dspring.test.context.failure.threshold=1000000`.

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/property-sources.adoc

@@ -16,7 +16,7 @@ SPI, but `@TestPropertySource` is not supported with implementations of the olde
 `ContextLoader` SPI.
 
 Implementations of `SmartContextLoader` gain access to merged test property source values
-through the `getPropertySourceDescriptors()` and `getPropertySourceProperties()` methods in
+through the `getPropertySourceLocations()` and `getPropertySourceProperties()` methods in
 `MergedContextConfiguration`.
 ====
 
@@ -26,23 +26,17 @@ through the `getPropertySourceDescriptors()` and `getPropertySourceProperties()`
 You can configure test properties files by using the `locations` or `value` attribute of
 `@TestPropertySource`.
 
-By default, both traditional and XML-based `java.util.Properties` file formats are
-supported -- for example, `"classpath:/com/example/test.properties"` or
-`"file:///path/to/file.xml"`. As of Spring Framework 6.1, you can configure a custom
-`PropertySourceFactory` via the `factory` attribute in `@TestPropertySource` in order to
-support a different file format such as JSON, YAML, etc.
+Both traditional and XML-based properties file formats are supported -- for example,
+`"classpath:/com/example/test.properties"` or `"file:///path/to/file.xml"`.
 
 Each path is interpreted as a Spring `Resource`. A plain path (for example,
 `"test.properties"`) is treated as a classpath resource that is relative to the package
 in which the test class is defined. A path starting with a slash is treated as an
 absolute classpath resource (for example: `"/org/example/test.xml"`). A path that
 references a URL (for example, a path prefixed with `classpath:`, `file:`, or `http:`) is
-loaded by using the specified resource protocol.
-
-Property placeholders in paths (such as `${...}`) will be resolved against the `Environment`.
-
-As of Spring Framework 6.1, resource location patterns are also supported — for
-example, `"classpath*:/config/*.properties"`.
+loaded by using the specified resource protocol. Resource location wildcards (such as
+`{asterisk}{asterisk}/{asterisk}.properties`) are not permitted: Each location must
+evaluate to exactly one `.properties` or `.xml` resource.
 
 The following example uses a test properties file:
 
@@ -86,20 +80,6 @@ a Java properties file:
 * `key:value`
 * `key value`
 
-[TIP]
-====
-Although properties can be defined using any of the above syntax variants and any number
-of spaces between the key and the value, it is recommended that you use one syntax
-variant and consistent spacing within your test suite — for example, consider always
-using `key = value` instead of `key= value`, `key=value`, etc. Similarly, if you define
-inlined properties using text blocks you should consistently use text blocks for inlined
-properties throughout your test suite.
-
-The reason is that the exact strings you provide will be used to determine the key for
-the context cache. Consequently, to benefit from the context cache you must ensure that
-you define inlined properties consistently.
-====
-
 The following example sets two inlined properties:
 
 [tabs]
@@ -109,61 +89,24 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
 	@ContextConfiguration
-	@TestPropertySource(properties = {"timezone = GMT", "port = 4242"}) // <1>
+	@TestPropertySource(properties = {"timezone = GMT", "port: 4242"}) // <1>
 	class MyIntegrationTests {
 		// class body...
 	}
 ----
-<1> Setting two properties via an array of strings.
+<1> Setting two properties by using two variations of the key-value syntax.
 
 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
 	@ContextConfiguration
-	@TestPropertySource(properties = ["timezone = GMT", "port = 4242"]) // <1>
+	@TestPropertySource(properties = ["timezone = GMT", "port: 4242"]) // <1>
 	class MyIntegrationTests {
 		// class body...
 	}
 ----
-<1> Setting two properties via an array of strings.
-======
-
-As of Spring Framework 6.1, you can use _text blocks_ to define multiple inlined
-properties in a single `String`. The following example sets two inlined properties using
-a text block:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@ContextConfiguration
-	@TestPropertySource(properties = """
-		timezone = GMT
-		port = 4242
-		""") // <1>
-	class MyIntegrationTests {
-		// class body...
-	}
-----
-<1> Setting two properties via a text block.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@ContextConfiguration
-	@TestPropertySource(properties = ["""
-		timezone = GMT
-		port = 4242
-		"""]) // <1>
-	class MyIntegrationTests {
-		// class body...
-	}
-----
-<1> Setting two properties via a text block.
+<1> Setting two properties by using two variations of the key-value syntax.
 ======
 
 [NOTE]
@@ -223,7 +166,7 @@ Java::
 	@ContextConfiguration
 	@TestPropertySource(
 		locations = "/test.properties",
-		properties = {"timezone = GMT", "port = 4242"}
+		properties = {"timezone = GMT", "port: 4242"}
 	)
 	class MyIntegrationTests {
 		// class body...
@@ -236,7 +179,7 @@ Kotlin::
 ----
 	@ContextConfiguration
 	@TestPropertySource("/test.properties",
-			properties = ["timezone = GMT", "port = 4242"]
+			properties = ["timezone = GMT", "port: 4242"]
 	)
 	class MyIntegrationTests {
 		// class body...

framework-docs/modules/ROOT/pages/testing/testcontext-framework/executing-sql.adoc

@@ -95,22 +95,13 @@ In addition to the aforementioned mechanisms for running SQL scripts programmati
 you can declaratively configure SQL scripts in the Spring TestContext Framework.
 Specifically, you can declare the `@Sql` annotation on a test class or test method to
 configure individual SQL statements or the resource paths to SQL scripts that should be
-run against a given database before or after an integration test class or test method.
-Support for `@Sql` is provided by the `SqlScriptsTestExecutionListener`, which is enabled
-by default.
+run against a given database before or after an integration test method. Support for
+`@Sql` is provided by the `SqlScriptsTestExecutionListener`, which is enabled by default.
 
-[NOTE]
-====
-Method-level `@Sql` declarations override class-level declarations by default, but this
-behavior may be configured per test class or per test method via `@SqlMergeMode`. See
-xref:testing/testcontext-framework/executing-sql.adoc#testcontext-executing-sql-declaratively-script-merging[Merging and Overriding Configuration with `@SqlMergeMode`]
-for further details.
-
-However, this does not apply to class-level declarations configured for the
-`BEFORE_TEST_CLASS` or `AFTER_TEST_CLASS` execution phases. Such declarations cannot be
-overridden, and the corresponding scripts and statements will be executed once per class
-in addition to any method-level scripts and statements.
-====
+NOTE: Method-level `@Sql` declarations override class-level declarations by default. As
+of Spring Framework 5.2, however, this behavior may be configured per test class or per
+test method via `@SqlMergeMode`. See
+xref:testing/testcontext-framework/executing-sql.adoc#testcontext-executing-sql-declaratively-script-merging[Merging and Overriding Configuration with `@SqlMergeMode`] for further details.
 
 [[testcontext-executing-sql-declaratively-script-resources]]
 === Path Resource Semantics
@@ -183,25 +174,17 @@ script, depending on where `@Sql` is declared. If a default cannot be detected,
   defined in the class `com.example.MyTest`, the corresponding default script is
   `classpath:com/example/MyTest.testMethod.sql`.
 
-[[testcontext-executing-sql-declaratively-logging]]
-=== Logging SQL Scripts and Statements
-
-If you want to see which SQL scripts are being executed, set the
-`org.springframework.test.context.jdbc` logging category to `DEBUG`.
-
-If you want to see which SQL statements are being executed, set the
-`org.springframework.jdbc.datasource.init` logging category to `DEBUG`.
-
 [[testcontext-executing-sql-declaratively-multiple-annotations]]
 === Declaring Multiple `@Sql` Sets
 
 If you need to configure multiple sets of SQL scripts for a given test class or test
 method but with different syntax configuration, different error handling rules, or
-different execution phases per set, you can declare multiple instances of `@Sql`. You can
-either use `@Sql` as a repeatable annotation, or you can use the `@SqlGroup` annotation
-as an explicit container for declaring multiple instances of `@Sql`.
+different execution phases per set, you can declare multiple instances of `@Sql`. With
+Java 8, you can use `@Sql` as a repeatable annotation. Otherwise, you can use the
+`@SqlGroup` annotation as an explicit container for declaring multiple instances of
+`@Sql`.
 
-The following example shows how to use `@Sql` as a repeatable annotation:
+The following example shows how to use `@Sql` as a repeatable annotation with Java 8:
 
 [tabs]
 ======
@@ -221,12 +204,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	@Test
-	@Sql("/test-schema.sql", config = SqlConfig(commentPrefix = "`"))
-	@Sql("/test-user-data.sql")
-	fun userTest() {
-		// run code that uses the test schema and test data
-	}
+	// Repeatable annotations with non-SOURCE retention are not yet supported by Kotlin
 ----
 ======
 
@@ -234,8 +212,9 @@ In the scenario presented in the preceding example, the `test-schema.sql` script
 different syntax for single-line comments.
 
 The following example is identical to the preceding example, except that the `@Sql`
-declarations are grouped together within `@SqlGroup`. The use of `@SqlGroup` is optional,
-but you may need to use `@SqlGroup` for compatibility with other JVM languages.
+declarations are grouped together within `@SqlGroup`. With Java 8 and above, the use of
+`@SqlGroup` is optional, but you may need to use `@SqlGroup` for compatibility with
+other JVM languages such as Kotlin.
 
 [tabs]
 ======
@@ -260,8 +239,7 @@ Kotlin::
 	@Test
 	@SqlGroup(
 		Sql("/test-schema.sql", config = SqlConfig(commentPrefix = "`")),
-		Sql("/test-user-data.sql")
-	)
+		Sql("/test-user-data.sql"))
 	fun userTest() {
 		// Run code that uses the test schema and test data
 	}
@@ -271,10 +249,10 @@ Kotlin::
 [[testcontext-executing-sql-declaratively-script-execution-phases]]
 === Script Execution Phases
 
-By default, SQL scripts are run before the corresponding test method. However, if you
-need to run a particular set of scripts after the test method (for example, to clean up
-database state), you can set the `executionPhase` attribute in `@Sql` to
-`AFTER_TEST_METHOD`, as the following example shows:
+By default, SQL scripts are run before the corresponding test method. However, if
+you need to run a particular set of scripts after the test method (for example, to clean
+up database state), you can use the `executionPhase` attribute in `@Sql`, as the
+following example shows:
 
 [tabs]
 ======
@@ -303,11 +281,12 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
 	@Test
-	@Sql("create-test-data.sql",
-		config = SqlConfig(transactionMode = ISOLATED))
-	@Sql("delete-test-data.sql",
-		config = SqlConfig(transactionMode = ISOLATED),
-		executionPhase = AFTER_TEST_METHOD)
+	@SqlGroup(
+		Sql("create-test-data.sql",
+			config = SqlConfig(transactionMode = ISOLATED)),
+		Sql("delete-test-data.sql",
+			config = SqlConfig(transactionMode = ISOLATED),
+			executionPhase = AFTER_TEST_METHOD))
 	fun userTest() {
 		// run code that needs the test data to be committed
 		// to the database outside of the test's transaction
@@ -315,60 +294,9 @@ Kotlin::
 ----
 ======
 
-NOTE: `ISOLATED` and `AFTER_TEST_METHOD` are statically imported from
+Note that `ISOLATED` and `AFTER_TEST_METHOD` are statically imported from
 `Sql.TransactionMode` and `Sql.ExecutionPhase`, respectively.
 
-As of Spring Framework 6.1, it is possible to run a particular set of scripts before or
-after the test class by setting the `executionPhase` attribute in a class-level `@Sql`
-declaration to `BEFORE_TEST_CLASS` or `AFTER_TEST_CLASS`, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@SpringJUnitConfig
-	@Sql(scripts = "/test-schema.sql", executionPhase = BEFORE_TEST_CLASS)
-	class DatabaseTests {
-
-		@Test
-		void emptySchemaTest() {
-			// run code that uses the test schema without any test data
-		}
-
-		@Test
-		@Sql("/test-user-data.sql")
-		void userTest() {
-			// run code that uses the test schema and test data
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@SpringJUnitConfig
-	@Sql("/test-schema.sql", executionPhase = BEFORE_TEST_CLASS)
-	class DatabaseTests {
-
-		@Test
-		fun emptySchemaTest() {
-			// run code that uses the test schema without any test data
-		}
-
-		@Test
-		@Sql("/test-user-data.sql")
-		fun userTest() {
-			// run code that uses the test schema and test data
-		}
-	}
-----
-======
-
-NOTE: `BEFORE_TEST_CLASS` is statically imported from `Sql.ExecutionPhase`.
-
 [[testcontext-executing-sql-declaratively-script-configuration]]
 === Script Configuration with `@SqlConfig`
 
@@ -396,7 +324,7 @@ individual attributes in {api-spring-framework}/test/context/jdbc/Sql.html[`@Sql
 {api-spring-framework}/test/context/jdbc/SqlConfig.html[`@SqlConfig`] for details.
 
 [[testcontext-executing-sql-declaratively-tx]]
-==== Transaction management for `@Sql`
+*Transaction management for `@Sql`*
 
 By default, the `SqlScriptsTestExecutionListener` infers the desired transaction
 semantics for scripts configured by using `@Sql`. Specifically, SQL scripts are run

framework-docs/modules/ROOT/pages/testing/testcontext-framework/support-classes.adoc

@@ -177,7 +177,7 @@ following features above and beyond the feature set that Spring supports for JUn
 TestNG:
 
 * Dependency injection for test constructors, test methods, and test lifecycle callback
-  methods. See xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-di[Dependency Injection with the `SpringExtension`] for further details.
+  methods. See xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-di[Dependency Injection with `SpringExtension`] for further details.
 * Powerful support for link:https://junit.org/junit5/docs/current/user-guide/#extensions-conditions[conditional
   test execution] based on SpEL expressions, environment variables, system properties,
   and so on. See the documentation for `@EnabledIf` and `@DisabledIf` in
@@ -310,19 +310,17 @@ See the documentation for `@SpringJUnitConfig` and `@SpringJUnitWebConfig` in
 xref:testing/annotations/integration-junit-jupiter.adoc[Spring JUnit Jupiter Testing Annotations] for further details.
 
 [[testcontext-junit-jupiter-di]]
-=== Dependency Injection with the `SpringExtension`
+=== Dependency Injection with `SpringExtension`
 
-The `SpringExtension` implements the
+`SpringExtension` implements the
 link:https://junit.org/junit5/docs/current/user-guide/#extensions-parameter-resolution[`ParameterResolver`]
 extension API from JUnit Jupiter, which lets Spring provide dependency injection for test
 constructors, test methods, and test lifecycle callback methods.
 
-Specifically, the `SpringExtension` can inject dependencies from the test's
+Specifically, `SpringExtension` can inject dependencies from the test's
 `ApplicationContext` into test constructors and methods that are annotated with
-Spring's `@BeforeTransaction` and `@AfterTransaction` or JUnit's `@BeforeAll`,
-`@AfterAll`, `@BeforeEach`, `@AfterEach`, `@Test`, `@RepeatedTest`, `@ParameterizedTest`,
-and others.
-
+`@BeforeAll`, `@AfterAll`, `@BeforeEach`, `@AfterEach`, `@Test`, `@RepeatedTest`,
+`@ParameterizedTest`, and others.
 
 [[testcontext-junit-jupiter-di-constructor]]
 ==== Constructor Injection
@@ -536,7 +534,7 @@ The _Spring TestContext Framework_ has supported the use of test-related annotat
 Framework 5.3 class-level test configuration annotations were not _inherited_ from
 enclosing classes like they are from superclasses.
 
-Spring Framework 5.3 introduced first-class support for inheriting test class
+Spring Framework 5.3 introduces first-class support for inheriting test class
 configuration from enclosing classes, and such configuration will be inherited by
 default. To change from the default `INHERIT` mode to `OVERRIDE` mode, you may annotate
 an individual `@Nested` test class with

framework-docs/modules/ROOT/pages/testing/testcontext-framework/tx.adoc

@@ -295,56 +295,14 @@ behavior after your test runs (if the test was configured to commit the transact
 `TransactionalTestExecutionListener` supports the `@BeforeTransaction` and
 `@AfterTransaction` annotations for exactly such scenarios. You can annotate any `void`
 method in a test class or any `void` default method in a test interface with one of these
-annotations, and the `TransactionalTestExecutionListener` ensures that your
-before-transaction method or after-transaction method runs at the appropriate time.
+annotations, and the `TransactionalTestExecutionListener` ensures that your before
+transaction method or after transaction method runs at the appropriate time.
 
-[NOTE]
-====
-Generally speaking, `@BeforeTransaction` and `@AfterTransaction` methods must not accept
-any arguments.
-
-However, as of Spring Framework 6.1, for tests using the 
-xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-extension[`SpringExtension`]
-with JUnit Jupiter, `@BeforeTransaction` and `@AfterTransaction` methods may optionally
-accept arguments which will be resolved by any registered JUnit `ParameterResolver`
-extension such as the `SpringExtension`. This means that JUnit-specific arguments like
-`TestInfo` or beans from the test's `ApplicationContext` may be provided to
-`@BeforeTransaction` and `@AfterTransaction` methods, as demonstrated in the following
-example.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-@BeforeTransaction
-void verifyInitialDatabaseState(@Autowired DataSource dataSource) {
-	// Use the DataSource to verify the initial state before a transaction is started
-}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-@BeforeTransaction
-fun verifyInitialDatabaseState(@Autowired dataSource: DataSource) {
-	// Use the DataSource to verify the initial state before a transaction is started
-}
-----
-======
-====
-
-[TIP]
-====
-Any before methods (such as methods annotated with JUnit Jupiter's `@BeforeEach`) and any
-after methods (such as methods annotated with JUnit Jupiter's `@AfterEach`) are run
-within the test-managed transaction for a transactional test method.
-
-Similarly, methods annotated with `@BeforeTransaction` or `@AfterTransaction` are only
-run for transactional test methods.
-====
+TIP: Any before methods (such as methods annotated with JUnit Jupiter's `@BeforeEach`)
+and any after methods (such as methods annotated with JUnit Jupiter's `@AfterEach`) are
+run within a transaction. In addition, methods annotated with `@BeforeTransaction` or
+`@AfterTransaction` are not run for test methods that are not configured to run within a
+transaction.
 
 [[testcontext-tx-mgr-config]]
 == Configuring a Transaction Manager

framework-docs/modules/ROOT/pages/web/webflux-webclient/client-filter.adoc

@@ -148,75 +148,5 @@ Kotlin::
 ----
 ======
 
-The example below demonstrates how to use the `ExchangeFilterFunction` interface to create
-a custom filter class that helps with computing a `Content-Length` header for `PUT` and `POST`
-`multipart/form-data` requests using buffering.
 
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-public class MultipartExchangeFilterFunction implements ExchangeFilterFunction {
 
-    @Override
-    public Mono<ClientResponse> filter(ClientRequest request, ExchangeFunction next) {
-        if (MediaType.MULTIPART_FORM_DATA.includes(request.headers().getContentType())
-                && (request.method() == HttpMethod.PUT || request.method() == HttpMethod.POST)) {
-            return next.exchange(ClientRequest.from(request).body((outputMessage, context) ->
-                request.body().insert(new BufferingDecorator(outputMessage), context)).build()
-            );
-        } else {
-            return next.exchange(request);
-        }
-    }
-
-    private static final class BufferingDecorator extends ClientHttpRequestDecorator {
-
-        private BufferingDecorator(ClientHttpRequest delegate) {
-            super(delegate);
-        }
-
-        @Override
-        public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
-            return DataBufferUtils.join(body).flatMap(buffer -> {
-                getHeaders().setContentLength(buffer.readableByteCount());
-                return super.writeWith(Mono.just(buffer));
-            });
-        }
-    }
-}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-class MultipartExchangeFilterFunction : ExchangeFilterFunction {
-
-    override fun filter(request: ClientRequest, next: ExchangeFunction): Mono<ClientResponse> {
-        return if (MediaType.MULTIPART_FORM_DATA.includes(request.headers().getContentType())
-            && (request.method() == HttpMethod.PUT || request.method() == HttpMethod.POST)) {
-            next.exchange(ClientRequest.from(request)
-                .body { message, context -> request.body().insert(BufferingDecorator(message), context) }
-                .build())
-        }
-        else {
-            next.exchange(request)
-        }
-
-    }
-
-    private class BufferingDecorator(delegate: ClientHttpRequest) : ClientHttpRequestDecorator(delegate) {
-        override fun writeWith(body: Publisher<out DataBuffer>): Mono<Void> {
-            return DataBufferUtils.join(body)
-                .flatMap {
-                    headers.contentLength = it.readableByteCount().toLong()
-                    super.writeWith(Mono.just(it))
-                }
-        }
-    }
-}
-----
-======

framework-docs/modules/ROOT/pages/web/webflux/ann-rest-exceptions.adoc

@@ -67,44 +67,52 @@ from an existing `ProblemDetail`. This could be done centrally, e.g. from an
 
 
 [[webflux-ann-rest-exceptions-i18n]]
-== Customization and i18n
+== Internationalization
 [.small]#xref:web/webmvc/mvc-ann-rest-exceptions.adoc#mvc-ann-rest-exceptions-i18n[See equivalent in the Servlet stack]#
 
-It is a common requirement to customize and internationalize error response details.
-It is also good practice to customize the problem details for Spring WebFlux exceptions
-to avoid revealing implementation details. This section describes the support for that.
+It is a common requirement to internationalize error response details, and good practice
+to customize the problem details for Spring WebFlux exceptions. This is supported as follows:
 
-An `ErrorResponse` exposes message codes for "type", "title", and "detail", as well as
-message code arguments for the "detail" field. `ResponseEntityExceptionHandler` resolves
-these through a xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
-and updates the corresponding `ProblemDetail` fields accordingly.
+- Each `ErrorResponse` exposes a message code and arguments to resolve the "detail" field
+through a xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource].
+The actual message code value is parameterized with placeholders, e.g.
+`+"HTTP method {0} not supported"+` to be expanded from the arguments.
+- Each `ErrorResponse` also exposes a message code to resolve the "title" field.
+- `ResponseEntityExceptionHandler` uses the message code and arguments to resolve the
+"detail" and the "title" fields.
 
-The default strategy for message codes follows the pattern:
-
-`problemDetail.[type|title|detail].[fully qualified exception class name]`
-
-An `ErrorResponse` may expose more than one message code, typically adding a suffix
-to the default message code. The table below lists message codes, and arguments for
-Spring WebFlux exceptions:
+By default, the message code for the "detail" field is "problemDetail." + the fully
+qualified exception class name. Some exceptions may expose additional message codes in
+which case a suffix is added to the default message code. The table below lists message
+arguments and codes for Spring WebFlux exceptions:
 
 [[webflux-ann-rest-exceptions-codes]]
 [cols="1,1,2", options="header"]
 |===
 | Exception | Message Code | Message Code Arguments
 
-| `HandlerMethodValidationException`
+| `UnsupportedMediaTypeStatusException`
 | (default)
-| `+{0}+` list all validation errors.
-Message codes and arguments for each error are also resolved via `MessageSource`.
+| `+{0}+` the media type that is not supported, `+{1}+` list of supported media types
 
-| `MethodNotAllowedException`
-| (default)
-| `+{0}+` the current HTTP method, `+{1}+` the list of supported HTTP methods
+| `UnsupportedMediaTypeStatusException`
+| (default) + ".parseError"
+|
 
 | `MissingRequestValueException`
 | (default)
 | `+{0}+` a label for the value (e.g. "request header", "cookie value", ...), `+{1}+` the value name
 
+| `UnsatisfiedRequestParameterException`
+| (default)
+| `+{0}+` the list of parameter conditions
+
+| `WebExchangeBindException`
+| (default)
+| `+{0}+` the list of global errors, `+{1}+` the list of field errors.
+Message codes and arguments for each error within the `BindingResult` are also resolved
+via `MessageSource`.
+
 | `NotAcceptableStatusException`
 | (default)
 | `+{0}+` list of supported media types
@@ -117,32 +125,14 @@ Message codes and arguments for each error are also resolved via `MessageSource`
 | (default)
 | `+{0}+` the failure reason provided to the class constructor
 
-| `UnsupportedMediaTypeStatusException`
+| `MethodNotAllowedException`
 | (default)
-| `+{0}+` the media type that is not supported, `+{1}+` list of supported media types
-
-| `UnsupportedMediaTypeStatusException`
-| (default) + ".parseError"
-|
-
-| `UnsatisfiedRequestParameterException`
-| (default)
-| `+{0}+` the list of parameter conditions
-
-| `WebExchangeBindException`
-| (default)
-| `+{0}+` the list of global errors, `+{1}+` the list of field errors.
-Message codes and arguments for each error are also resolved via `MessageSource`.
+| `+{0}+` the current HTTP method, `+{1}+` the list of supported HTTP methods
 
 |===
 
-NOTE: Unlike other exceptions, the message arguments for
-`WebExchangeBindException` and `HandlerMethodValidationException` are based on a list of
-`MessageSourceResolvable` errors that can also be customized through a
-xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
-resource bundle. See
-xref:core/validation/beanvalidation.adoc#validation-beanvalidation-spring-method-i18n[Customizing Validation Errors]
-for more details.
+By default, the message code for the "title" field is "problemDetail.title." + the fully
+qualified exception class name.
 
 
 

framework-docs/modules/ROOT/pages/web/webflux/config.adoc

@@ -700,8 +700,9 @@ Java::
 
 		@Override
 		public void configurePathMatch(PathMatchConfigurer configurer) {
-			configurer.addPathPrefix(
-					"/api", HandlerTypePredicate.forAnnotation(RestController.class));
+			configurer
+				.setUseCaseSensitiveMatch(true)
+				.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController.class));
 		}
 	}
 ----
@@ -716,8 +717,9 @@ Kotlin::
 
 		@Override
 		fun configurePathMatch(configurer: PathMatchConfigurer) {
-			configurer.addPathPrefix(
-					"/api", HandlerTypePredicate.forAnnotation(RestController::class.java))
+			configurer
+				.setUseCaseSensitiveMatch(true)
+				.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController::class.java))
 		}
 	}
 ----
@@ -738,59 +740,6 @@ reliance on it.
 
 
 
-
-[[webflux-config-blocking-execution]]
-== Blocking Execution
-
-The WebFlux Java config allows you to customize blocking execution in WebFlux.
-
-You can have blocking controller methods called on a separate thread by providing
-an `AsyncTaskExecutor` such as the
-{api-spring-framework}/core/task/VirtualThreadTaskExecutor.html[`VirtualThreadTaskExecutor`]
-as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@Configuration
-	@EnableWebFlux
-	public class WebConfig implements WebFluxConfigurer {
-
-		@Override
-		public void configureBlockingExecution(BlockingExecutionConfigurer configurer) {
-			AsyncTaskExecutor executor = ...
-			configurer.setExecutor(executor);
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Configuration
-	@EnableWebFlux
-	class WebConfig : WebFluxConfigurer {
-
-		@Override
-		fun configureBlockingExecution(configurer: BlockingExecutionConfigurer) {
-			val executor = ...
-			configurer.setExecutor(executor)
-		}
-	}
-----
-======
-
-By default, controller methods whose return type is not recognized by the configured
-`ReactiveAdapterRegistry` are considered blocking, but you can set a custom controller
-method predicate via `BlockingExecutionConfigurer`.
-
-
-
-
 [[webflux-config-websocket-service]]
 == WebSocketService
 

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-initbinder.adoc

@@ -3,21 +3,23 @@
 
 [.small]#xref:web/webmvc/mvc-controller/ann-initbinder.adoc[See equivalent in the Servlet stack]#
 
-`@Controller` or `@ControllerAdvice` classes can have `@InitBinder` methods to
-initialize `WebDataBinder` instances that in turn can:
+`@Controller` or `@ControllerAdvice` classes can have `@InitBinder` methods, to
+initialize instances of `WebDataBinder`. Those, in turn, are used to:
 
-* Bind request parameters to a model object.
-* Convert request values from string to object property types.
-* Format model object properties as strings when rendering HTML forms.
+* Bind request parameters (that is, form data or query) to a model object.
+* Convert `String`-based request values (such as request parameters, path variables,
+headers, cookies, and others) to the target type of controller method arguments.
+* Format model object values as `String` values when rendering HTML forms.
 
-In an `@Controller`, `DataBinder` customizations apply locally within the controller,
-or even to a specific model attribute referenced by name through the annotation.
-In an `@ControllerAdvice` customizations can apply to all or a subset of controllers.
+`@InitBinder` methods can register controller-specific `java.beans.PropertyEditor` or
+Spring `Converter` and `Formatter` components. In addition, you can use the
+xref:web/webflux/config.adoc#webflux-config-conversion[WebFlux Java configuration] to register `Converter` and
+`Formatter` types in a globally shared `FormattingConversionService`.
 
-You can register `PropertyEditor`, `Converter`, and `Formatter` components in the
-`DataBinder` for type conversion. Alternatively, you can use the
-xref:web/webflux/config.adoc#webflux-config-conversion[WebFlux config] to register
-`Converter` and `Formatter` components  in a globally shared `FormattingConversionService`.
+`@InitBinder` methods support many of the same arguments that `@RequestMapping` methods
+do, except for `@ModelAttribute` (command object) arguments. Typically, they are declared
+with a `WebDataBinder` argument, for registrations, and a `void` return value.
+The following example uses the `@InitBinder` annotation:
 
 --
 [tabs]
@@ -110,5 +112,4 @@ Kotlin::
 == Model Design
 [.small]#xref:web/webmvc/mvc-controller/ann-initbinder.adoc#mvc-ann-initbinder-model-design[See equivalent in the Servlet stack]#
 
-include::partial$web/web-data-binding-model-design.adoc[]
 

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/modelattrib-method-args.adoc

@@ -3,8 +3,11 @@
 
 [.small]#xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[See equivalent in the Servlet stack]#
 
-The `@ModelAttribute` method parameter annotation binds request parameters onto a model
-object. For example:
+You can use the `@ModelAttribute` annotation on a method argument to access an attribute from the
+model or have it instantiated if not present. The model attribute is also overlaid with
+the values of query parameters and form fields whose names match to field names. This is
+referred to as data binding, and it saves you from having to deal with parsing and
+converting individual query parameters and form fields. The following example binds an instance of `Pet`:
 
 [tabs]
 ======
@@ -15,7 +18,7 @@ Java::
 	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
 	public String processSubmit(@ModelAttribute Pet pet) { } // <1>
 ----
-<1> Bind to an instance of `Pet`.
+<1> Bind an instance of `Pet`.
 
 Kotlin::
 +
@@ -24,66 +27,28 @@ Kotlin::
 	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
 	fun processSubmit(@ModelAttribute pet: Pet): String { } // <1>
 ----
-<1> Bind to an instance of `Pet`.
+<1> Bind an instance of `Pet`.
 ======
 
-The `Pet` instance may be:
+The `Pet` instance in the preceding example is resolved as follows:
 
-* Accessed from the model where it could have been added by a
-  xref:web/webflux/controller/ann-modelattrib-methods.adoc[`Model`].
-* Accessed from the HTTP session if the model attribute was listed in
-  the class-level xref:web/webflux/controller/ann-methods/sessionattributes.adoc[`@SessionAttributes`].
-* Instantiated through a default constructor.
-* Instantiated through a "`primary constructor`" with arguments that match to Servlet
-request parameters. Argument names are determined through runtime-retained parameter
-names in the bytecode.
+* From the model if already added through xref:web/webflux/controller/ann-modelattrib-methods.adoc[`Model`].
+* From the HTTP session through xref:web/webflux/controller/ann-methods/sessionattributes.adoc[`@SessionAttributes`].
+* From the invocation of a default constructor.
+* From the invocation of a "`primary constructor`" with arguments that match query
+parameters or form fields. Argument names are determined through JavaBeans
+`@ConstructorProperties` or through runtime-retained parameter names in the bytecode.
 
-By default, both constructor and property
-xref:core/validation/beans-beans.adoc#beans-binding[data binding] are applied. However,
-model object design requires careful consideration, and for security reasons it is
-recommended either to use an object tailored specifically for web binding, or to apply
-constructor binding only. If property binding must still be used, then _allowedFields_
-patterns should be set to limit which properties can be set. For further details on this
-and example configuration, see
-xref:web/webflux/controller/ann-initbinder.adoc#webflux-ann-initbinder-model-design[model design].
+After the model attribute instance is obtained, data binding is applied. The
+`WebExchangeDataBinder` class matches names of query parameters and form fields to field
+names on the target `Object`. Matching fields are populated after type conversion is applied
+where necessary. For more on data binding (and validation), see
+xref:web/webmvc/mvc-config/validation.adoc[Validation]. For more on customizing data binding, see
+xref:web/webflux/controller/ann-initbinder.adoc[`DataBinder`].
 
-When using constructor binding, you can customize request parameter names through an
-`@BindParam` annotation. For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	class Account {
-
-	    private final String firstName;
-
-		public Account(@BindParam("first-name") String firstName) {
-			this.firstName = firstName;
-		}
-	}
-----
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class Account(@BindParam("first-name") val firstName: String)
-----
-======
-
-NOTE: The `@BindParam` may also be placed on the fields that correspond to constructor
-parameters. While `@BindParam` is supported out of the box, you can also use a
-different annotation by setting a `DataBinder.NameResolver` on `DataBinder`
-
-WebFlux, unlike Spring MVC, supports reactive types in the model, e.g. `Mono<Account>`.
-You can declare a `@ModelAttribute` argument with or without a reactive type wrapper, and
-it will be resolved accordingly to the actual value.
-
-If data binding results in errors, by default a `WebExchangeBindException` is raised,
-but you can also add a `BindingResult` argument immediately next to the `@ModelAttribute`
-in order to handle such errors in the controller method. For example:
+Data binding can result in errors. By default, a `WebExchangeBindException` is raised, but,
+to check for such errors in the controller method, you can add a `BindingResult` argument
+immediately next to the `@ModelAttribute`, as the following example shows:
 
 [tabs]
 ======
@@ -116,9 +81,49 @@ Kotlin::
 <1> Adding a `BindingResult`.
 ======
 
-To use a `BindingResult` argument, you must declare the `@ModelAttribute` argument before
-it without a reactive type wrapper. If you want to use the reactive, you can handle errors
-directly through it. For example:
+You can automatically apply validation after data binding by adding the
+`jakarta.validation.Valid` annotation or Spring's `@Validated` annotation (see also
+xref:core/validation/beanvalidation.adoc[Bean Validation] and
+xref:web/webmvc/mvc-config/validation.adoc[Spring validation]). The following example uses the `@Valid` annotation:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
+	public String processSubmit(@Valid @ModelAttribute("pet") Pet pet, BindingResult result) { // <1>
+		if (result.hasErrors()) {
+			return "petForm";
+		}
+		// ...
+	}
+----
+<1> Using `@Valid` on a model attribute argument.
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+----
+	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
+	fun processSubmit(@Valid @ModelAttribute("pet") pet: Pet, result: BindingResult): String { // <1>
+		if (result.hasErrors()) {
+			return "petForm"
+		}
+		// ...
+	}
+----
+<1> Using `@Valid` on a model attribute argument.
+======
+
+Spring WebFlux, unlike Spring MVC, supports reactive types in the model -- for example,
+`Mono<Account>` or `io.reactivex.Single<Account>`. You can declare a `@ModelAttribute` argument
+with or without a reactive type wrapper, and it will be resolved accordingly,
+to the actual value if necessary. However, note that, to use a `BindingResult`
+argument, you must declare the `@ModelAttribute` argument before it without a reactive
+type wrapper, as shown earlier. Alternatively, you can handle any errors through the
+reactive type, as the following example shows:
 
 [tabs]
 ======
@@ -155,49 +160,10 @@ Kotlin::
 ----
 ======
 
-You can automatically apply validation after data binding by adding the
-`jakarta.validation.Valid` annotation or Spring's `@Validated` annotation (see
-xref:core/validation/beanvalidation.adoc[Bean Validation] and
-xref:web/webmvc/mvc-config/validation.adoc[Spring validation]). For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
-	public String processSubmit(@Valid @ModelAttribute("pet") Pet pet, BindingResult result) { // <1>
-		if (result.hasErrors()) {
-			return "petForm";
-		}
-		// ...
-	}
-----
-<1> Using `@Valid` on a model attribute argument.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
-	fun processSubmit(@Valid @ModelAttribute("pet") pet: Pet, result: BindingResult): String { // <1>
-		if (result.hasErrors()) {
-			return "petForm"
-		}
-		// ...
-	}
-----
-<1> Using `@Valid` on a model attribute argument.
-======
-
-If method validation applies because other parameters have `@Constraint` annotations,
-then `HandlerMethodValidationException` would be raised instead. See the section on
-controller method xref:web/webmvc/mvc-controller/ann-validation.adoc[Validation].
-
-TIP: Using `@ModelAttribute` is optional. By default, any argument that is not a simple
-value type as determined by
-{api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty]
-_AND_ that is not resolved by any other argument resolver is treated as an `@ModelAttribute`.
+Note that use of `@ModelAttribute` is optional -- for example, to set its attributes.
+By default, any argument that is not a simple value type (as determined by
+{api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty])
+and is not resolved by any other argument resolver is treated as if it were annotated
+with `@ModelAttribute`.
 
 

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/multipart-forms.adoc

@@ -176,10 +176,6 @@ Kotlin::
 ======
 --
 
-If method validation applies because other parameters have `@Constraint` annotations,
-then `HandlerMethodValidationException` is raised instead. See the section on
-xref:web/webflux/controller/ann-validation.adoc[Validation].
-
 To access all multipart data as a `MultiValueMap`, you can use `@RequestBody`,
 as the following example shows:
 
@@ -310,3 +306,5 @@ file upload.
 
 Received part events can also be relayed to another service by using the `WebClient`.
 See xref:web/webflux-webclient/client-body.adoc#webflux-client-body-multipart[Multipart Data].
+
+

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/requestbody.adoc

@@ -89,33 +89,4 @@ Kotlin::
 ----
 ======
 
-You can also declare an `Errors` parameter for access to validation errors, but in
-that case the request body must not be a `Mono`, and will be resolved first:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@PostMapping("/accounts")
-	public void handle(@Valid @RequestBody Account account, Errors errors) {
-		// use one of the onError* operators...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@PostMapping("/accounts")
-	fun handle(@Valid @RequestBody account: Mono<Account>) {
-		// ...
-	}
-----
-======
-
-If method validation applies because other parameters have `@Constraint` annotations,
-then `HandlerMethodValidationException` is raised instead. For more details, see the
-section on xref:web/webflux/controller/ann-validation.adoc[Validation].
 

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-requestmapping.adoc

@@ -1,15 +1,8 @@
 [[webflux-ann-requestmapping]]
-= Mapping Requests
+= Request Mapping
 
 [.small]#xref:web/webmvc/mvc-controller/ann-requestmapping.adoc[See equivalent in the Servlet stack]#
 
-This section discusses request mapping for annotated controllers.
-
-[[webflux-ann-requestmapping-annotation]]
-== `@RequestMapping`
-
-[.small]#xref:web/webmvc/mvc-controller/ann-requestmapping.adoc#mvc-ann-requestmapping-annotation[See equivalent in the Servlet stack]#
-
 The `@RequestMapping` annotation is used to map requests to controllers methods. It has
 various attributes to match by URL, HTTP method, request parameters, headers, and media
 types. You can use it at the class level to express shared mappings or at the method level
@@ -507,68 +500,3 @@ Kotlin::
 
 
 
-[[webflux-ann-httpexchange-annotation]]
-== `@HttpExchange`
-[.small]#xref:web/webmvc/mvc-controller/ann-requestmapping.adoc#mvc-ann-httpexchange-annotation[See equivalent in the Reactive stack]#
-
-As an alternative to  `@RequestMapping`, you can also handle requests with `@HttpExchange`
-methods. Such methods are declared on an
-xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] and can be used as
-a client via `HttpServiceProxyFactory` or implemented by a server `@Controller`.
-
-For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@RestController
-	@HttpExchange("/persons")
-	class PersonController {
-
-		@GetExchange("/{id}")
-		public Person getPerson(@PathVariable Long id) {
-			// ...
-		}
-
-		@PostExchange
-		@ResponseStatus(HttpStatus.CREATED)
-		public void add(@RequestBody Person person) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@RestController
-	@HttpExchange("/persons")
-	class PersonController {
-
-		@GetExchange("/{id}")
-		fun getPerson(@PathVariable id: Long): Person {
-			// ...
-		}
-
-		@PostExchange
-		@ResponseStatus(HttpStatus.CREATED)
-		fun add(@RequestBody person: Person) {
-			// ...
-		}
-	}
-----
-======
-
-There some differences between `@HttpExchange` and `@RequestMapping` since the
-former needs to remain suitable for client and server use. For example, while
-`@RequestMapping` can be declared to handle any number of paths and each path can
-be a pattern, `@HttpExchange` must be declared with a single, concrete path. There are
-also differences in the supported method parameters. Generally, `@HttpExchange` supports
-a subset of method parameters that `@RequestMapping` does, excluding any parameters that
-are server side only. For details see the list of supported method parameters for
-xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[HTTP interface] and for
-xref:web/webflux/controller/ann-methods/arguments.adoc[@RequestMapping].

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-validation.adoc

@@ -1,111 +0,0 @@
-[[mvc-ann-validation]]
-= Validation
-
-[.small]#xref:web/webmvc/mvc-controller/ann-validation.adoc[See equivalent in the Servlet stack]#
-
-Spring WebFlux has built-in xref:core/validation/validator.adoc[Validation] support for
-`@RequestMapping` methods, including the option to use
-xref:core/validation/beanvalidation.adoc[Java Bean Validation].
-The validation support works on two levels.
-
-First, method parameters such as
-xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
-xref:web/webflux/controller/ann-methods/requestbody.adoc[@RequestBody], and
-xref:web/webflux/controller/ann-methods/multipart-forms.adoc[@RequestPart] do perform
-validation if annotated with Jakarta's `@Valid` or Spring's `@Validated` annotation, and
-raise `MethodArgumentNotValidException` in case of validation errors. If you want to handle
-the errors in the controller method instead, you can declare an `Errors` or `BindingResult`
-method parameter immediately after the validated parameter.
-
-Second, if https://beanvalidation.org/[Java Bean Validation] is present _AND_ other method
-parameters, e.g. `@RequestHeader`, `@RequestParam`, `@PathVariable` have `@Constraint`
-annotations, then method validation is applied to all method arguments, raising
-`HandlerMethodValidationException` in case of validation errors. You can still declare an
-`Errors` or `BindingResult` after an `@Valid` method parameter, and handle validation
-errors within the controller method, as long as there are no validation errors on other
-method arguments.
-
-You can configure a `Validator` globally through the
-xref:web/webflux/config.adoc#webflux-config-validation[WebMvc config], or locally
-through an xref:web/webflux/controller/ann-initbinder.adoc[@InitBinder] method in an
-`@Controller` or `@ControllerAdvice`. You can also use multiple validators.
-
-NOTE: If a controller has a class level `@Validated`, then
-xref:core/validation/beanvalidation.adoc#validation-beanvalidation-spring-method[method validation is applied]
-through an AOP proxy. In order to take advantage of the Spring MVC built-in support for
-method validation added in Spring Framework 6.1, you need to remove the class level
-`@Validated` annotation from the controller.
-
-The xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses] section provides further
-details on how `MethodArgumentNotValidException` and `HandlerMethodValidationException`
-are handled, and also how their rendering can be customized through a `MessageSource` and
-locale and language specific resource bundles.
-
-For further custom handling of method validation errors, you can extend
-`ResponseEntityExceptionHandler` or use an `@ExceptionHandler` method in a controller
-or in a `@ControllerAdvice`, and handle `HandlerMethodValidationException` directly.
-The exception contains a list of``ParameterValidationResult``s that group validation errors
-by method parameter. You can either iterate over those, or provide a visitor with callback
-methods by controller method parameter type:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	HandlerMethodValidationException ex = ... ;
-
-	ex.visitResults(new HandlerMethodValidationException.Visitor() {
-
-		@Override
-		public void requestHeader(RequestHeader requestHeader, ParameterValidationResult result) {
-				// ...
-		}
-
-		@Override
-		public void requestParam(@Nullable RequestParam requestParam, ParameterValidationResult result) {
-				// ...
-		}
-
-		@Override
-		public void modelAttribute(@Nullable ModelAttribute modelAttribute, ParameterErrors errors) {
-
-		// ...
-
-		@Override
-		public void other(ParameterValidationResult result) {
-				// ...
-		}
-	});
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	// HandlerMethodValidationException
-	val ex
-
-	ex.visitResults(object : HandlerMethodValidationException.Visitor {
-
-		override fun requestHeader(requestHeader: RequestHeader, result: ParameterValidationResult) {
-				// ...
-        }
-
-		override fun requestParam(requestParam: RequestParam?, result: ParameterValidationResult) {
-				// ...
-        }
-
-		override fun modelAttribute(modelAttribute: ModelAttribute?, errors: ParameterErrors) {
-				// ...
-        }
-
-		// ...
-
-		override fun other(result: ParameterValidationResult) {
-				// ...
-        }
-	})
-----
-======

framework-docs/modules/ROOT/pages/web/webflux/reactive-spring.adoc

@@ -368,34 +368,31 @@ collecting to a `MultiValueMap`.
 === Forwarded Headers
 [.small]#xref:web/webmvc/filters.adoc#filters-forwarded-headers[See equivalent in the Servlet stack]#
 
-include::partial$web/forwarded-headers.adoc[]
+As a request goes through proxies (such as load balancers), the host, port, and
+scheme may change. That makes it a challenge, from a client perspective, to create links that point to the correct
+host, port, and scheme.
 
-
-
-[[webflux-forwarded-headers-transformer]]
-=== ForwardedHeaderTransformer
+https://tools.ietf.org/html/rfc7239[RFC 7239] defines the `Forwarded` HTTP header
+that proxies can use to provide information about the original request. There are other
+non-standard headers, too, including `X-Forwarded-Host`, `X-Forwarded-Port`,
+`X-Forwarded-Proto`, `X-Forwarded-Ssl`, and `X-Forwarded-Prefix`.
 
 `ForwardedHeaderTransformer` is a component that modifies the host, port, and scheme of
 the request, based on forwarded headers, and then removes those headers. If you declare
 it as a bean with the name `forwardedHeaderTransformer`, it will be
 xref:web/webflux/reactive-spring.adoc#webflux-web-handler-api-special-beans[detected] and used.
 
-NOTE: In 5.1 `ForwardedHeaderFilter` was deprecated and superseded by
-`ForwardedHeaderTransformer` so forwarded headers can be processed earlier, before the
-exchange is created. If the filter is configured anyway, it is taken out of the list of
-filters, and `ForwardedHeaderTransformer` is used instead.
-
-
-
-[[webflux-forwarded-headers-security]]
-=== Security Considerations
-
-There are security considerations for forwarded headers since an application cannot know
+There are security considerations for forwarded headers, since an application cannot know
 if the headers were added by a proxy, as intended, or by a malicious client. This is why
 a proxy at the boundary of trust should be configured to remove untrusted forwarded traffic coming
 from the outside. You can also configure the `ForwardedHeaderTransformer` with
 `removeOnly=true`, in which case it removes but does not use the headers.
 
+NOTE: In 5.1 `ForwardedHeaderFilter` was deprecated and superseded by
+`ForwardedHeaderTransformer` so forwarded headers can be processed earlier, before the
+exchange is created. If the filter is configured anyway, it is taken out of the list of
+filters, and `ForwardedHeaderTransformer` is used instead.
+
 
 
 [[webflux-filters]]

framework-docs/modules/ROOT/pages/web/webmvc-client.adoc

@@ -6,26 +6,6 @@ This section describes options for client-side access to REST endpoints.
 
 
 
-[[webmvc-restclient]]
-== `RestClient`
-
-`RestClient` is a synchronous HTTP client that exposes a modern, fluent API.
-
-See xref:integration/rest-clients.adoc#rest-restclient[`RestClient`] for more details.
-
-
-
-
-[[webmvc-webclient]]
-== `WebClient`
-
-`WebClient` is a reactive client to perform HTTP requests with a fluent API.
-
-See xref:web/webflux-webclient.adoc[WebClient] for more details.
-
-
-
-
 [[webmvc-resttemplate]]
 == `RestTemplate`
 
@@ -33,8 +13,37 @@ See xref:web/webflux-webclient.adoc[WebClient] for more details.
 Spring REST client and exposes a simple, template-method API over underlying HTTP client
 libraries.
 
+NOTE: As of 5.0 the `RestTemplate` is in maintenance mode, with only requests for minor
+changes and bugs to be accepted. Please, consider using the
+xref:web/webflux-webclient.adoc[WebClient] which offers a more modern API and
+supports sync, async, and streaming scenarios.
+
 See xref:integration/rest-clients.adoc[REST Endpoints] for details.
 
+
+
+
+[[webmvc-webclient]]
+== `WebClient`
+
+`WebClient` is a non-blocking, reactive client to perform HTTP requests. It was
+introduced in 5.0 and offers a modern alternative to the `RestTemplate`, with efficient
+support for both synchronous and asynchronous, as well as streaming scenarios.
+
+In contrast to `RestTemplate`, `WebClient` supports the following:
+
+* Non-blocking I/O.
+* Reactive Streams back pressure.
+* High concurrency with fewer hardware resources.
+* Functional-style, fluent API that takes advantage of Java 8 lambdas.
+* Synchronous and asynchronous interactions.
+* Streaming up to or streaming down from a server.
+
+See xref:web/webflux-webclient.adoc[WebClient] for more details.
+
+
+
+
 [[webmvc-http-interface]]
 == HTTP Interface
 

framework-docs/modules/ROOT/pages/web/webmvc/filters.adoc

@@ -26,16 +26,18 @@ available through the `ServletRequest.getParameter{asterisk}()` family of method
 
 
 
-[[forwarded-headers]]
+[[filters-forwarded-headers]]
 == Forwarded Headers
 [.small]#xref:web/webflux/reactive-spring.adoc#webflux-forwarded-headers[See equivalent in the Reactive stack]#
 
-include::partial$web/forwarded-headers.adoc[]
+As a request goes through proxies (such as load balancers) the host, port, and
+scheme may change, and that makes it a challenge to create links that point to the correct
+host, port, and scheme from a client perspective.
 
-
-
-[[filters-forwarded-headers-non-forwardedheaderfilter]]
-=== ForwardedHeaderFilter
+https://tools.ietf.org/html/rfc7239[RFC 7239] defines the `Forwarded` HTTP header
+that proxies can use to provide information about the original request. There are other
+non-standard headers, too, including `X-Forwarded-Host`, `X-Forwarded-Port`,
+`X-Forwarded-Proto`, `X-Forwarded-Ssl`, and `X-Forwarded-Prefix`.
 
 `ForwardedHeaderFilter` is a Servlet filter that modifies the request in order to
 a) change the host, port, and scheme based on `Forwarded` headers, and b) to remove those
@@ -43,22 +45,12 @@ headers to eliminate further impact. The filter relies on wrapping the request,
 therefore it must be ordered ahead of other filters, such as `RequestContextFilter`, that
 should work with the modified and not the original request.
 
-
-
-[[filters-forwarded-headers-security]]
-=== Security Considerations
-
 There are security considerations for forwarded headers since an application cannot know
 if the headers were added by a proxy, as intended, or by a malicious client. This is why
 a proxy at the boundary of trust should be configured to remove untrusted `Forwarded`
 headers that come from the outside. You can also configure the `ForwardedHeaderFilter`
 with `removeOnly=true`, in which case it removes but does not use the headers.
 
-
-
-[[filters-forwarded-headers-dispatcher]]
-=== Dispatcher Types
-
 In order to support xref:web/webmvc/mvc-ann-async.adoc[asynchronous requests] and error dispatches this
 filter should be mapped with `DispatcherType.ASYNC` and also `DispatcherType.ERROR`.
 If using Spring Framework's `AbstractAnnotationConfigDispatcherServletInitializer`

framework-docs/modules/ROOT/pages/web/webmvc/mvc-ann-async.adoc

@@ -92,7 +92,7 @@ Kotlin::
 ======
 
 The return value can then be obtained by running the given task through the
-xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-configuration-spring-mvc[configured] `AsyncTaskExecutor`.
+xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-configuration-spring-mvc[configured] `TaskExecutor`.
 
 
 
@@ -128,7 +128,7 @@ Here is a very concise overview of Servlet asynchronous request processing:
 
 * The controller returns a `Callable`.
 * Spring MVC calls `request.startAsync()` and submits the `Callable` to
-  an `AsyncTaskExecutor` for processing in a separate thread.
+  a `TaskExecutor` for processing in a separate thread.
 * Meanwhile, the `DispatcherServlet` and all filters exit the Servlet container thread,
   but the response remains open.
 * Eventually the `Callable` produces a result, and Spring MVC dispatches the request back
@@ -404,10 +404,11 @@ TIP: Spring MVC supports Reactor and RxJava through the
 
 For streaming to the response, reactive back pressure is supported, but writes to the
 response are still blocking and are run on a separate thread through the
-xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-configuration-spring-mvc[configured]
-`AsyncTaskExecutor`, to avoid blocking the upstream source such as a `Flux` returned
-from `WebClient`.
-
+xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-configuration-spring-mvc[configured] `TaskExecutor`, to avoid
+blocking the upstream source (such as a `Flux` returned from `WebClient`).
+By default, `SimpleAsyncTaskExecutor` is used for the blocking writes, but that is not
+suitable under load. If you plan to stream with a reactive type, you should use the
+xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-configuration-spring-mvc[MVC configuration] to configure a task executor.
 
 
 
@@ -493,7 +494,7 @@ In `web.xml` configuration, you can add `<async-supported>true</async-supported>
 [[mvc-ann-async-configuration-spring-mvc]]
 === Spring MVC
 
-The MVC configuration exposes the following options for asynchronous request processing:
+The MVC configuration exposes the following options related to asynchronous request processing:
 
 * Java configuration: Use the `configureAsyncSupport` callback on `WebMvcConfigurer`.
 * XML namespace: Use the `<async-support>` element under `<mvc:annotation-driven>`.
@@ -503,9 +504,10 @@ You can configure the following:
 * Default timeout value for async requests, which if not set, depends
 on the underlying Servlet container.
 * `AsyncTaskExecutor` to use for blocking writes when streaming with
-xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-reactive-types[Reactive Types] and for
-executing `Callable` instances returned from controller methods.
-The one used by default is not suitable for production under load.
+xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-reactive-types[Reactive Types] and for executing `Callable` instances returned from
+controller methods. We highly recommended configuring this property if you
+stream with reactive types or have controller methods that return `Callable`, since
+by default, it is a `SimpleAsyncTaskExecutor`.
 * `DeferredResultProcessingInterceptor` implementations and `CallableProcessingInterceptor` implementations.
 
 Note that you can also set the default timeout value on a `DeferredResult`,

framework-docs/modules/ROOT/pages/web/webmvc/mvc-ann-rest-exceptions.adoc

@@ -67,25 +67,24 @@ from an existing `ProblemDetail`. This could be done centrally, e.g. from an
 
 
 [[mvc-ann-rest-exceptions-i18n]]
-== Customization and i18n
+== Internationalization
 [.small]#xref:web/webflux/ann-rest-exceptions.adoc#webflux-ann-rest-exceptions-i18n[See equivalent in the Reactive stack]#
 
-It is a common requirement to customize and internationalize error response details.
-It is also good practice to customize the problem details for Spring MVC exceptions
-to avoid revealing implementation details. This section describes the support for that.
+It is a common requirement to internationalize error response details, and good practice
+to customize the problem details for Spring MVC exceptions. This is supported as follows:
 
-An `ErrorResponse` exposes message codes for "type", "title", and "detail", as well as
-message code arguments for the "detail" field. `ResponseEntityExceptionHandler` resolves
-these through a xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
-and updates the corresponding `ProblemDetail` fields accordingly.
+- Each `ErrorResponse` exposes a message code and arguments to resolve the "detail" field
+through a xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource].
+The actual message code value is parameterized with placeholders, e.g.
+`+"HTTP method {0} not supported"+` to be expanded from the arguments.
+- Each `ErrorResponse` also exposes a message code to resolve the "title" field.
+- `ResponseEntityExceptionHandler` uses the message code and arguments to resolve the
+"detail" and the "title" fields.
 
-The default strategy for message codes follows the pattern:
-
-`problemDetail.[type|title|detail].[fully qualified exception class name]`
-
-An `ErrorResponse` may expose more than one message code, typically adding a suffix
-to the default message code. The table below lists message codes, and arguments for
-Spring MVC exceptions:
+By default, the message code for the "detail" field is "problemDetail." + the fully
+qualified exception class name. Some exceptions may expose additional message codes in
+which case a suffix is added to the default message code. The table below lists message
+arguments and codes for Spring MVC exceptions:
 
 [[mvc-ann-rest-exceptions-codes]]
 [cols="1,1,2", options="header"]
@@ -100,11 +99,6 @@ Spring MVC exceptions:
 | (default)
 | `+{0}+` property name, `+{1}+` property value
 
-| `HandlerMethodValidationException`
-| (default)
-| `+{0}+` list all validation errors.
-Message codes and arguments for each error are also resolved via `MessageSource`.
-
 | `HttpMediaTypeNotAcceptableException`
 | (default)
 | `+{0}+` list of supported media types
@@ -136,7 +130,8 @@ Message codes and arguments for each error are also resolved via `MessageSource`
 | `MethodArgumentNotValidException`
 | (default)
 | `+{0}+` the list of global errors, `+{1}+` the list of field errors.
-  Message codes and arguments for each error are also resolvedvia `MessageSource`.
+  Message codes and arguments for each error within the `BindingResult` are also resolved
+  via `MessageSource`.
 
 | `MissingRequestHeaderException`
 | (default)
@@ -166,10 +161,6 @@ Message codes and arguments for each error are also resolved via `MessageSource`
 | (default)
 |
 
-| `NoResourceFoundException`
-| (default)
-|
-
 | `TypeMismatchException`
 | (default)
 | `+{0}+` property name, `+{1}+` property value
@@ -180,13 +171,8 @@ Message codes and arguments for each error are also resolved via `MessageSource`
 
 |===
 
-NOTE: Unlike other exceptions, the message arguments for
-`MethodArgumentValidException` and `HandlerMethodValidationException` are baed on a list of
-`MessageSourceResolvable` errors that can also be customized through a
-xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
-resource bundle. See
-xref:core/validation/beanvalidation.adoc#validation-beanvalidation-spring-method-i18n[Customizing Validation Errors]
-for more details.
+By default, the message code for the "title" field is "problemDetail.title." + the fully
+qualified exception class name.
 
 
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-config/validation.adoc

@@ -6,7 +6,7 @@
 By default, if xref:core/validation/beanvalidation.adoc#validation-beanvalidation-overview[Bean Validation] is present
 on the classpath (for example, Hibernate Validator), the `LocalValidatorFactoryBean` is
 registered as a global xref:core/validation/validator.adoc[Validator] for use with `@Valid` and
-`@Validated` on controller method arguments.
+`Validated` on controller method arguments.
 
 In Java configuration, you can customize the global `Validator` instance, as the
 following example shows:

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-initbinder.adoc

@@ -1,27 +1,25 @@
 [[mvc-ann-initbinder]]
-= `@InitBinder`
+= `DataBinder`
 
 [.small]#xref:web/webflux/controller/ann-initbinder.adoc[See equivalent in the Reactive stack]#
 
-`@Controller` or `@ControllerAdvice` classes can have `@InitBinder` methods to
-initialize `WebDataBinder` instances that in turn can:
+`@Controller` or `@ControllerAdvice` classes can have `@InitBinder` methods that
+initialize instances of `WebDataBinder`, and those, in turn, can:
 
-* Bind request parameters to a model object.
-* Convert request values from string to object property types.
-* Format model object properties as strings when rendering HTML forms.
+* Bind request parameters (that is, form or query data) to a model object.
+* Convert String-based request values (such as request parameters, path variables,
+headers, cookies, and others) to the target type of controller method arguments.
+* Format model object values as `String` values when rendering HTML forms.
 
-In an `@Controller`, `DataBinder` customizations apply locally within the controller,
-or even to a specific model attribute referenced by name through the annotation.
-In an `@ControllerAdvice` customizations can apply to all or a subset of controllers.
+`@InitBinder` methods can register controller-specific `java.beans.PropertyEditor` or
+Spring `Converter` and `Formatter` components. In addition, you can use the
+xref:web/webmvc/mvc-config/conversion.adoc[MVC config] to register `Converter` and `Formatter`
+types in a globally shared `FormattingConversionService`.
 
-You can register `PropertyEditor`, `Converter`, and `Formatter` components in the
-`DataBinder` for type conversion. Alternatively, you can use the
-xref:web/webmvc/mvc-config/conversion.adoc[MVC config] to register `Converter` and
-`Formatter` components  in a globally shared `FormattingConversionService`.
-
-`@InitBinder` methods can have many of the same arguments that `@RequestMapping` methods
-have, with the notable exception of `@ModelAttribute`. Typically, such methods have a
-`WebDataBinder` argument (for registrations) and a `void` return value, for example:
+`@InitBinder` methods support many of the same arguments that `@RequestMapping` methods
+do, except for `@ModelAttribute` (command object) arguments. Typically, they are declared
+with a `WebDataBinder` argument (for registrations) and a `void` return value.
+The following listing shows an example:
 
 [tabs]
 ======

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc

@@ -3,8 +3,11 @@
 
 [.small]#xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[See equivalent in the Reactive stack]#
 
-The `@ModelAttribute` method parameter annotation binds request parameters onto a model
-object. For example:
+You can use the `@ModelAttribute` annotation on a method argument to access an attribute from
+the model or have it be instantiated if not present. The model attribute is also overlain with
+values from HTTP Servlet request parameters whose names match to field names. This is referred
+to as data binding, and it saves you from having to deal with parsing and converting individual
+query parameters and form fields. The following example shows how to do so:
 
 [tabs]
 ======
@@ -17,7 +20,7 @@ Java::
 		// method logic...
 	}
 ----
-<1> Bind to an instance of `Pet`.
+<1> Bind an instance of `Pet`.
 
 Kotlin::
 +
@@ -28,27 +31,30 @@ fun processSubmit(@ModelAttribute pet: Pet): String { // <1>
 	// method logic...
 }
 ----
-<1> Bind to an instance of `Pet`.
+<1> Bind an instance of `Pet`.
 ======
 
-The `Pet` instance may be:
+The `Pet` instance above is sourced in one of the following ways:
 
-* Accessed from the model where it could have been added by a
+* Retrieved from the model where it may have been added by a
   xref:web/webmvc/mvc-controller/ann-modelattrib-methods.adoc[@ModelAttribute method].
-* Accessed from the HTTP session if the model attribute was listed in
+* Retrieved from the HTTP session if the model attribute was listed in
   the class-level xref:web/webmvc/mvc-controller/ann-methods/sessionattributes.adoc[`@SessionAttributes`] annotation.
-* Obtained through a `Converter` if the model attribute name matches the name of a
-  request value such as a path variable or a request parameter (example follows).
-* Instantiated through a default constructor.
+* Obtained through a `Converter` where the model attribute name matches the name of a
+  request value such as a path variable or a request parameter (see next example).
+* Instantiated using its default constructor.
 * Instantiated through a "`primary constructor`" with arguments that match to Servlet
-  request parameters. Argument names are determined through runtime-retained parameter
-  names in the bytecode.
+  request parameters. Argument names are determined through JavaBeans
+  `@ConstructorProperties` or through runtime-retained parameter names in the bytecode.
 
-As mentioned above, a  `Converter<String, T>` may be used to obtain the model object if
-the model attribute name matches to the name of a request value such as a path variable or a
-request parameter, _and_ there is a compatible `Converter<String, T>`. In the below example,
-the model attribute name `account` matches URI path variable `account`, and there is a
-registered `Converter<String, Account>` that perhaps retrieves it from a persistence store:
+One alternative to using a xref:web/webmvc/mvc-controller/ann-modelattrib-methods.adoc[@ModelAttribute method] to
+supply it or relying on the framework to create the model attribute, is to have a
+`Converter<String, T>` to provide the instance. This is applied when the model attribute
+name matches to the name of a request value such as a path variable or a request
+parameter, and there is a `Converter` from `String` to the model attribute type.
+In the following example, the model attribute name is `account` which matches the URI
+path variable `account`, and there is a registered `Converter<String, Account>` which
+could load the `Account` from a data store:
 
 [tabs]
 ======
@@ -61,6 +67,7 @@ Java::
 		// ...
 	}
 ----
+<1> Bind an instance of `Account` using an explicit attribute name.
 
 Kotlin::
 +
@@ -71,101 +78,19 @@ Kotlin::
 		// ...
 	}
 ----
+<1> Bind an instance of `Account` using an explicit attribute name.
 ======
 
-By default, both constructor and property
-xref:core/validation/beans-beans.adoc#beans-binding[data binding] are applied. However,
-model object design requires careful consideration, and for security reasons it is
-recommended either to use an object tailored specifically for web binding, or to apply
-constructor binding only. If property binding must still be used, then _allowedFields_
-patterns should be set to limit which properties can be set. For further details on this
-and example configuration, see
-xref:web/webmvc/mvc-controller/ann-initbinder.adoc#mvc-ann-initbinder-model-design[model design].
+After the model attribute instance is obtained, data binding is applied. The
+`WebDataBinder` class matches Servlet request parameter names (query parameters and form
+fields) to field names on the target `Object`. Matching fields are populated after type
+conversion is applied, where necessary. For more on data binding (and validation), see
+xref:web/webmvc/mvc-config/validation.adoc[Validation]. For more on customizing data binding, see
+xref:web/webmvc/mvc-controller/ann-initbinder.adoc[`DataBinder`].
 
-When using constructor binding, you can customize request parameter names through an
-`@BindParam` annotation. For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	class Account {
-
-	    private final String firstName;
-
-		public Account(@BindParam("first-name") String firstName) {
-			this.firstName = firstName;
-		}
-	}
-----
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class Account(@BindParam("first-name") val firstName: String)
-----
-======
-
-NOTE: The `@BindParam` may also be placed on the fields that correspond to constructor
-parameters. While `@BindParam` is supported out of the box, you can also use a
-different annotation by setting a `DataBinder.NameResolver` on `DataBinder`
-
-In some cases, you may want access to a model attribute without data binding. For such
-cases, you can inject the `Model` into the controller and access it directly or,
-alternatively, set `@ModelAttribute(binding=false)`, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@ModelAttribute
-	public AccountForm setUpForm() {
-		return new AccountForm();
-	}
-
-	@ModelAttribute
-	public Account findAccount(@PathVariable String accountId) {
-		return accountRepository.findOne(accountId);
-	}
-
-	@PostMapping("update")
-	public String update(AccountForm form, BindingResult result,
-			@ModelAttribute(binding=false) Account account) { // <1>
-		// ...
-	}
-----
-<1> Setting `@ModelAttribute(binding=false)`.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@ModelAttribute
-	fun setUpForm(): AccountForm {
-		return AccountForm()
-	}
-
-	@ModelAttribute
-	fun findAccount(@PathVariable accountId: String): Account {
-		return accountRepository.findOne(accountId)
-	}
-
-	@PostMapping("update")
-	fun update(form: AccountForm, result: BindingResult,
-			   @ModelAttribute(binding = false) account: Account): String { // <1>
-		// ...
-	}
-----
-<1> Setting `@ModelAt\tribute(binding=false)`.
-======
-
-If data binding results in errors, by default a `MethodArgumentNotValidException` is raised,
-but you can also add a `BindingResult` argument immediately next to the `@ModelAttribute`
-in order to handle such errors in the controller method. For example:
+Data binding can result in errors. By default, a `BindException` is raised. However, to check
+for such errors in the controller method, you can add a `BindingResult` argument immediately next
+to the `@ModelAttribute`, as the following example shows:
 
 [tabs]
 ======
@@ -198,10 +123,61 @@ Kotlin::
 <1> Adding a `BindingResult` next to the `@ModelAttribute`.
 ======
 
+In some cases, you may want access to a model attribute without data binding. For such
+cases, you can inject the `Model` into the controller and access it directly or,
+alternatively, set `@ModelAttribute(binding=false)`, as the following example shows:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	@ModelAttribute
+	public AccountForm setUpForm() {
+		return new AccountForm();
+	}
+
+	@ModelAttribute
+	public Account findAccount(@PathVariable String accountId) {
+		return accountRepository.findOne(accountId);
+	}
+
+	@PostMapping("update")
+	public String update(@Valid AccountForm form, BindingResult result,
+			@ModelAttribute(binding=false) Account account) { // <1>
+		// ...
+	}
+----
+<1> Setting `@ModelAttribute(binding=false)`.
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+----
+	@ModelAttribute
+	fun setUpForm(): AccountForm {
+		return AccountForm()
+	}
+
+	@ModelAttribute
+	fun findAccount(@PathVariable accountId: String): Account {
+		return accountRepository.findOne(accountId)
+	}
+
+	@PostMapping("update")
+	fun update(@Valid form: AccountForm, result: BindingResult,
+			   @ModelAttribute(binding = false) account: Account): String { // <1>
+		// ...
+	}
+----
+<1> Setting `@ModelAttribute(binding=false)`.
+======
+
 You can automatically apply validation after data binding by adding the
-`jakarta.validation.Valid` annotation or Spring's `@Validated` annotation.
-See xref:core/validation/beanvalidation.adoc[Bean Validation] and
-xref:web/webmvc/mvc-config/validation.adoc[Spring validation]. For example:
+`jakarta.validation.Valid` annotation or Spring's `@Validated` annotation
+(xref:core/validation/beanvalidation.adoc[Bean Validation] and
+xref:web/webmvc/mvc-config/validation.adoc[Spring validation]). The following example shows how to do so:
 
 [tabs]
 ======
@@ -234,13 +210,10 @@ Kotlin::
 <1> Validate the `Pet` instance.
 ======
 
-If there is no `BindingResult` parameter after the `@ModelAttribute`, then
-`MethodArgumentNotValueException` is raised with the validation errors. However, if method
-validation applies because other parameters have `@jakarta.validation.Constraint` annotations,
-then `HandlerMethodValidationException` is raised instead. For more details, see the section
-xref:web/webmvc/mvc-controller/ann-validation.adoc[Validation].
+Note that using `@ModelAttribute` is optional (for example, to set its attributes).
+By default, any argument that is not a simple value type (as determined by
+{api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty])
+and is not resolved by any other argument resolver is treated as if it were annotated
+with `@ModelAttribute`.
+
 
-TIP: Using `@ModelAttribute` is optional. By default, any parameter that is not a simple
-value type as determined by
-{api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty]
-_AND_ that is not resolved by any other argument resolver is treated as an `@ModelAttribute`.

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/multipart-forms.adoc

@@ -188,7 +188,8 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
 	@PostMapping("/")
-	public String handle(@Valid @RequestPart("meta-data") MetaData metadata, Errors errors) {
+	public String handle(@Valid @RequestPart("meta-data") MetaData metadata,
+			BindingResult result) {
 		// ...
 	}
 ----
@@ -198,14 +199,12 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
 	@PostMapping("/")
-	fun handle(@Valid @RequestPart("meta-data") metadata: MetaData, errors: Errors): String {
+	fun handle(@Valid @RequestPart("meta-data") metadata: MetaData,
+			result: BindingResult): String {
 		// ...
 	}
 ----
 ======
 
-If method validation applies because other parameters have `@Constraint` annotations,
-then `HandlerMethodValidationException` is raised instead. For more details, see the
-section on xref:web/webmvc/mvc-controller/ann-validation.adoc[Validation].
 
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/requestbody.adoc

@@ -48,7 +48,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
 	@PostMapping("/accounts")
-	public void handle(@Valid @RequestBody Account account, Errors errors) {
+	public void handle(@Valid @RequestBody Account account, BindingResult result) {
 		// ...
 	}
 ----
@@ -58,13 +58,10 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
 	@PostMapping("/accounts")
-	fun handle(@Valid @RequestBody account: Account, errors: Errors) {
+	fun handle(@Valid @RequestBody account: Account, result: BindingResult) {
 		// ...
 	}
 ----
 ======
 
-If method validation applies because other parameters have `@Constraint` annotations,
-then `HandlerMethodValidationException` is raised instead. For more details, see the
-section on xref:web/webmvc/mvc-controller/ann-validation.adoc[Validation].
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-requestmapping.adoc

@@ -1,17 +1,8 @@
 [[mvc-ann-requestmapping]]
-= Mapping Requests
+= Request Mapping
 
 [.small]#xref:web/webflux/controller/ann-requestmapping.adoc[See equivalent in the Reactive stack]#
 
-This section discusses request mapping for annotated controllers.
-
-
-
-[[mvc-ann-requestmapping-annotation]]
-== `@RequestMapping`
-
-[.small]#xref:web/webflux/controller/ann-requestmapping.adoc#webflux-ann-requestmapping-annotation[See equivalent in the Reactive stack]#
-
 You can use the `@RequestMapping` annotation to map requests to controllers methods. It has
 various attributes to match by URL, HTTP method, request parameters, headers, and media
 types. You can use it at the class level to express shared mappings or at the method level
@@ -558,68 +549,3 @@ Kotlin::
 
 
 
-[[mvc-ann-httpexchange-annotation]]
-== `@HttpExchange`
-[.small]#xref:web/webflux/controller/ann-requestmapping.adoc#webflux-ann-httpexchange-annotation[See equivalent in the Reactive stack]#
-
-As an alternative to  `@RequestMapping`, you can also handle requests with `@HttpExchange`
-methods. Such methods are declared on an
-xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] and can be used as
-a client via `HttpServiceProxyFactory` or implemented by a server `@Controller`.
-
-For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@RestController
-	@HttpExchange("/persons")
-	class PersonController {
-
-		@GetExchange("/{id}")
-		public Person getPerson(@PathVariable Long id) {
-			// ...
-		}
-
-		@PostExchange
-		@ResponseStatus(HttpStatus.CREATED)
-		public void add(@RequestBody Person person) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@RestController
-	@HttpExchange("/persons")
-	class PersonController {
-
-		@GetExchange("/{id}")
-		fun getPerson(@PathVariable id: Long): Person {
-			// ...
-		}
-
-		@PostExchange
-		@ResponseStatus(HttpStatus.CREATED)
-		fun add(@RequestBody person: Person) {
-			// ...
-		}
-	}
-----
-======
-
-There some differences between `@HttpExchange` and `@RequestMapping` since the
-former needs to remain suitable for client and server use. For example, while
-`@RequestMapping` can be declared to handle any number of paths and each path can
-be a pattern, `@HttpExchange` must be declared with a single, concrete path. There are
-also differences in the supported method parameters. Generally, `@HttpExchange` supports
-a subset of method parameters that `@RequestMapping` does, excluding any parameters that
-are server side only. For details see the list of supported method parameters for
-xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[HTTP interface] and for
-xref:web/webmvc/mvc-controller/ann-methods/arguments.adoc[@RequestMapping].

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-validation.adoc

@@ -1,112 +0,0 @@
-[[mvc-ann-validation]]
-= Validation
-
-[.small]#xref:web/webflux/controller/ann-validation.adoc[See equivalent in the Reactive stack]#
-
-Spring MVC has built-in xref:core/validation/validator.adoc[Validation] support for
-`@RequestMapping` methods, including the option to use
-xref:core/validation/beanvalidation.adoc[Java Bean Validation].
-The validation support works on two levels.
-
-First, method parameters such as
-xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
-xref:web/webmvc/mvc-controller/ann-methods/requestbody.adoc[@RequestBody], and
-xref:web/webmvc/mvc-controller/ann-methods/multipart-forms.adoc[@RequestPart] do perform
-validation if annotated with Jakarta's `@Valid` or Spring's `@Validated` annotation, and
-raise `MethodArgumentNotValidException` in case of validation errors. If you want to handle
-the errors in the controller method instead, you can declare an `Errors` or `BindingResult`
-method parameter immediately after the validated parameter.
-
-Second, if https://beanvalidation.org/[Java Bean Validation] is present _AND_ other method
-parameters, e.g. `@RequestHeader`, `@RequestParam`, `@PathVariable` have `@Constraint`
-annotations, then method validation is applied to all method arguments, raising
-`HandlerMethodValidationException` in case of validation errors. You can still declare an
-`Errors` or `BindingResult` after an `@Valid` method parameter, and handle validation
-errors within the controller method, as long as there are no validation errors on other
-method arguments. Method validation is also applied to the return value if the method
-is annotated with `@Valid` or has other `@Constraint` annotations.
-
-You can configure a `Validator` globally through the
-xref:web/webmvc/mvc-config/validation.adoc[WebMvc config], or locally through an
-xref:web/webmvc/mvc-controller/ann-initbinder.adoc[@InitBinder] method in an
-`@Controller` or `@ControllerAdvice`. You can also use multiple validators.
-
-NOTE: If a controller has a class level `@Validated`, then
-xref:core/validation/beanvalidation.adoc#validation-beanvalidation-spring-method[method validation is applied]
-through an AOP proxy. In order to take advantage of the Spring MVC built-in support for
-method validation added in Spring Framework 6.1, you need to remove the class level
-`@Validated` annotation from the controller.
-
-The xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses] section provides further
-details on how `MethodArgumentNotValidException` and `HandlerMethodValidationException`
-are handled, and also how their rendering can be customized through a `MessageSource` and
-locale and language specific resource bundles.
-
-For further custom handling of method validation errors, you can extend
-`ResponseEntityExceptionHandler` or use an `@ExceptionHandler` method in a controller
-or in a `@ControllerAdvice`, and handle `HandlerMethodValidationException` directly.
-The exception contains a list of``ParameterValidationResult``s that group validation errors
-by method parameter. You can either iterate over those, or provide a visitor with callback
-methods by controller method parameter type:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	HandlerMethodValidationException ex = ... ;
-
-	ex.visitResults(new HandlerMethodValidationException.Visitor() {
-
-		@Override
-		public void requestHeader(RequestHeader requestHeader, ParameterValidationResult result) {
-				// ...
-		}
-
-		@Override
-		public void requestParam(@Nullable RequestParam requestParam, ParameterValidationResult result) {
-				// ...
-		}
-
-		@Override
-		public void modelAttribute(@Nullable ModelAttribute modelAttribute, ParameterErrors errors) {
-
-		// ...
-
-		@Override
-		public void other(ParameterValidationResult result) {
-				// ...
-		}
-	});
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	// HandlerMethodValidationException
-	val ex
-
-	ex.visitResults(object : HandlerMethodValidationException.Visitor {
-
-		override fun requestHeader(requestHeader: RequestHeader, result: ParameterValidationResult) {
-				// ...
-        }
-
-		override fun requestParam(requestParam: RequestParam?, result: ParameterValidationResult) {
-				// ...
-        }
-
-		override fun modelAttribute(modelAttribute: ModelAttribute?, errors: ParameterErrors) {
-				// ...
-        }
-
-		// ...
-
-		override fun other(result: ParameterValidationResult) {
-				// ...
-        }
-	})
-----
-======

framework-docs/modules/ROOT/pages/web/webmvc/mvc-servlet/sequence.adoc

@@ -62,7 +62,8 @@ initialization parameters (`init-param` elements) to the Servlet declaration in
   The exception can then be caught with a `HandlerExceptionResolver` (for example, by using an
   `@ExceptionHandler` controller method) and handled as any others.
 
-  As of 6.1, this property is set to `true` and deprecated.
+  By default, this is set to `false`, in which case the `DispatcherServlet` sets the
+  response status to 404 (NOT_FOUND) without raising an exception.
 
   Note that, if xref:web/webmvc/mvc-config/default-servlet-handler.adoc[default servlet handling]  is
   also configured, unresolved requests are always forwarded to the default servlet

framework-docs/modules/ROOT/pages/web/websocket/server.adoc

@@ -280,7 +280,9 @@ The following example shows the XML configuration equivalent of the preceding ex
 NOTE: For client-side WebSocket configuration, you should use `WebSocketContainerFactoryBean`
 (XML) or `ContainerProvider.getWebSocketContainer()` (Java configuration).
 
-For Jetty, you need to supply a `Consumer` callback to configure the WebSocket server. For example:
+For Jetty, you need to supply a pre-configured Jetty `WebSocketServerFactory` and plug
+that into Spring's `DefaultHandshakeHandler` through your WebSocket Java config.
+The following example shows how to do so:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -290,20 +292,62 @@ For Jetty, you need to supply a `Consumer` callback to configure the WebSocket s
 
 		@Override
 		public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
-
-			JettyRequestUpgradeStrategy upgradeStrategy = new JettyRequestUpgradeStrategy();
-			upgradeStrategy.addWebSocketConfigurer(configurable -> {
-					policy.setInputBufferSize(8192);
-					policy.setIdleTimeout(600000);
-			});
-
 			registry.addHandler(echoWebSocketHandler(),
-				"/echo").setHandshakeHandler(new DefaultHandshakeHandler(upgradeStrategy));
+				"/echo").setHandshakeHandler(handshakeHandler());
+		}
+
+		@Bean
+		public DefaultHandshakeHandler handshakeHandler() {
+
+			WebSocketPolicy policy = new WebSocketPolicy(WebSocketBehavior.SERVER);
+			policy.setInputBufferSize(8192);
+			policy.setIdleTimeout(600000);
+
+			return new DefaultHandshakeHandler(
+					new JettyRequestUpgradeStrategy(new WebSocketServerFactory(policy)));
 		}
 
 	}
 ----
 
+The following example shows the XML configuration equivalent of the preceding example:
+
+[source,xml,indent=0,subs="verbatim,quotes,attributes"]
+----
+	<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:websocket="http://www.springframework.org/schema/websocket"
+		xsi:schemaLocation="
+			http://www.springframework.org/schema/beans
+			https://www.springframework.org/schema/beans/spring-beans.xsd
+			http://www.springframework.org/schema/websocket
+			https://www.springframework.org/schema/websocket/spring-websocket.xsd">
+
+		<websocket:handlers>
+			<websocket:mapping path="/echo" handler="echoHandler"/>
+			<websocket:handshake-handler ref="handshakeHandler"/>
+		</websocket:handlers>
+
+		<bean id="handshakeHandler" class="org.springframework...DefaultHandshakeHandler">
+			<constructor-arg ref="upgradeStrategy"/>
+		</bean>
+
+		<bean id="upgradeStrategy" class="org.springframework...JettyRequestUpgradeStrategy">
+			<constructor-arg ref="serverFactory"/>
+		</bean>
+
+		<bean id="serverFactory" class="org.eclipse.jetty...WebSocketServerFactory">
+			<constructor-arg>
+				<bean class="org.eclipse.jetty...WebSocketPolicy">
+					<constructor-arg value="SERVER"/>
+					<property name="inputBufferSize" value="8092"/>
+					<property name="idleTimeout" value="600000"/>
+				</bean>
+			</constructor-arg>
+		</bean>
+
+	</beans>
+----
 
 
 

framework-docs/modules/ROOT/pages/web/websocket/stomp/ordered-messages.adoc

@@ -6,7 +6,7 @@ written to WebSocket sessions. As the channel is backed by a `ThreadPoolExecutor
 are processed in different threads, and the resulting sequence received by the client may
 not match the exact order of publication.
 
-To enable ordered publishing, set the `setPreservePublishOrder` flag as follows:
+If this is an issue, enable the `setPreservePublishOrder` flag, as the following example shows:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -47,22 +47,5 @@ When the flag is set, messages within the same client session are published to t
 `clientOutboundChannel` one at a time, so that the order of publication is guaranteed.
 Note that this incurs a small performance overhead, so you should enable it only if it is required.
 
-The same also applies to messages from the client, which are sent to the `clientInboundChannel`,
-from where they are handled according to their destination prefix. As the channel is backed by
-a `ThreadPoolExecutor`, messages are processed in different threads, and the resulting sequence
-of handling may not match the exact order in which they were received.
 
-To enable ordered publishing, set the `setPreserveReceiveOrder` flag as follows:
 
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Configuration
-	@EnableWebSocketMessageBroker
-	public class MyConfig implements WebSocketMessageBrokerConfigurer {
-
-		@Override
-		public void registerStompEndpoints(StompEndpointRegistry registry) {
-			registry.setPreserveReceiveOrder(true);
-		}
-	}
-----