Release v7.0.0-RC1

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

@@ -24,7 +24,7 @@ runs:
   using: composite
   steps:
     - name: Set Up Java
-      uses: actions/setup-java@v5
+      uses: actions/setup-java@v4
       with:
         distribution: ${{ inputs.java-early-access == 'true' && 'temurin' || (inputs.java-distribution || 'liberica') }}
         java-version: |
@@ -32,7 +32,7 @@ runs:
           ${{ inputs.java-toolchain == 'true' && '17' || '' }}
           25
     - name: Set Up Gradle
-      uses: gradle/actions/setup-gradle@4d9f0ba0025fe599b4ebab900eb7f3a1d93ef4c2 # v5.0.0
+      uses: gradle/actions/setup-gradle@ac638b010cf58a27ee6c972d7336334ccaf61c96 # v4.4.1
       with:
         cache-read-only: false
         develocity-access-key: ${{ inputs.develocity-access-key }}

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

@@ -17,14 +17,14 @@ runs:
   using: composite
   steps:
     - name: Set Up JFrog CLI
-      uses: jfrog/setup-jfrog-cli@5b06f730cc5a6f55d78b30753f8583454b08c0aa # v4.8.1
+      uses: jfrog/setup-jfrog-cli@f748a0599171a192a2668afee8d0497f7c1069df # v4.5.6
       env:
         JF_ENV_SPRING: ${{ inputs.jfrog-cli-config-token }}
     - name: Download Release Artifacts
       shell: bash
       run: jf rt download --spec ${{ format('{0}/artifacts.spec', github.action_path) }} --spec-vars 'buildName=${{ format('spring-framework-{0}', inputs.spring-framework-version) }};buildNumber=${{ github.run_number }}'
     - name: Sync
-      uses: spring-io/central-publish-action@0c03960e9b16fdfe70e2443e1d5393cbc3a35622 # v0.3.0
+      uses: spring-io/central-publish-action@0cdd90d12e6876341e82860d951e1bcddc1e51b6 # v0.2.0
       with:
         token: ${{ inputs.central-token-password }}
         token-name: ${{ inputs.central-token-username }}

.github/workflows/backport-bot.yml

@@ -18,9 +18,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Set up Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
         with:
           distribution: 'liberica'
           java-version: 17

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

@@ -13,7 +13,7 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Build and Publish
         id: build-and-publish
         uses: ./.github/actions/build
@@ -21,7 +21,7 @@ jobs:
           develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
           publish: true
       - name: Deploy
-        uses: spring-io/artifactory-deploy-action@926d7f7cc810569395346bf3a4d91b380b3e355b # v0.0.4
+        uses: spring-io/artifactory-deploy-action@dc1913008c0599f0c4b1fdafb6ff3c502b3565ea # v0.0.2
         with:
           artifact-properties: |
             /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false

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

@@ -10,7 +10,7 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Build
         id: build
         uses: ./.github/actions/build
@@ -19,7 +19,7 @@ jobs:
         uses: ./.github/actions/print-jvm-thread-dumps
       - name: Upload Build Reports
         if: failure()
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: build-reports
           path: '**/build/reports/'

.github/workflows/ci.yml

@@ -35,7 +35,7 @@ jobs:
           git config --global core.longPaths true
           Stop-Service -name Docker
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Build
         id: build
         uses: ./.github/actions/build

.github/workflows/deploy-docs.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Check out code
-      uses: actions/checkout@v6
+      uses: actions/checkout@v4
       with:
         fetch-depth: 1
         ref: docs-build

.github/workflows/release-milestone.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Build and Publish
         id: build-and-publish
         uses: ./.github/actions/build
@@ -21,7 +21,7 @@ jobs:
           develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
           publish: true
       - name: Stage Release
-        uses: spring-io/artifactory-deploy-action@926d7f7cc810569395346bf3a4d91b380b3e355b # v0.0.4
+        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
         with:
           artifact-properties: |
             /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
@@ -57,7 +57,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
       - name: Sync to Maven Central
         uses: ./.github/actions/sync-to-maven-central
         with:
@@ -73,7 +73,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Set up JFrog CLI
-        uses: jfrog/setup-jfrog-cli@5b06f730cc5a6f55d78b30753f8583454b08c0aa # v4.8.1
+        uses: jfrog/setup-jfrog-cli@dff217c085c17666e8849ebdbf29c8fe5e3995e6 # v4.5.2
         env:
           JF_ENV_SPRING: ${{ secrets.JF_ARTIFACTORY_SPRING }}
       - name: Promote build
@@ -86,7 +86,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
       - name: Create GitHub Release
         uses: ./.github/actions/create-github-release
         with:

.github/workflows/release.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Build and Publish
         id: build-and-publish
         uses: ./.github/actions/build
@@ -20,7 +20,7 @@ jobs:
           develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
           publish: true
       - name: Stage Release
-        uses: spring-io/artifactory-deploy-action@926d7f7cc810569395346bf3a4d91b380b3e355b # v0.0.4
+        uses: spring-io/artifactory-deploy-action@dc1913008c0599f0c4b1fdafb6ff3c502b3565ea # v0.0.2
         with:
           artifact-properties: |
             /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
@@ -56,7 +56,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
       - name: Sync to Maven Central
         uses: ./.github/actions/sync-to-maven-central
         with:
@@ -72,7 +72,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Set up JFrog CLI
-        uses: jfrog/setup-jfrog-cli@5b06f730cc5a6f55d78b30753f8583454b08c0aa # v4.8.1
+        uses: jfrog/setup-jfrog-cli@dff217c085c17666e8849ebdbf29c8fe5e3995e6 # v4.5.2
         env:
           JF_ENV_SPRING: ${{ secrets.JF_ARTIFACTORY_SPRING }}
       - name: Promote build
@@ -85,7 +85,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
       - name: Create GitHub Release
         uses: ./.github/actions/create-github-release
         with:

.github/workflows/update-antora-ui-spring.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        branch: [ '6.2.x', 'main' ]
+        branch: [ '6.1.x' ]
     steps:
       - uses: spring-io/spring-doc-actions/update-antora-spring-ui@5a57bcc6a0da2a1474136cf29571b277850432bc
         name: Update

.github/workflows/verify.yml

@@ -30,23 +30,23 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check Out Release Verification Tests
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           ref: 'v0.0.2'
           repository: spring-projects/spring-framework-release-verification
           token: ${{ secrets.token }}
       - name: Check Out Send Notification Action
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           path: send-notification
           sparse-checkout: .github/actions/send-notification
       - name: Set Up Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
         with:
           distribution: 'liberica'
           java-version: 17
       - name: Set Up Gradle
-        uses: gradle/actions/setup-gradle@4d9f0ba0025fe599b4ebab900eb7f3a1d93ef4c2 # v5.0.0
+        uses: gradle/actions/setup-gradle@ac638b010cf58a27ee6c972d7336334ccaf61c96 # v4.4.1
         with:
           cache-read-only: false
       - name: Configure Gradle Properties
@@ -64,7 +64,7 @@ jobs:
         run: ./gradlew spring-framework-release-verification-tests:test
       - name: Upload Build Reports on Failure
         if: failure()
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v4
         with:
           name: build-reports
           path: '**/build/reports/'

.gitignore

@@ -38,7 +38,7 @@ bin
 .springBeans
 spring-*/src/main/java/META-INF/MANIFEST.MF
 
-# IntelliJ IDEA artifacts and output dirs
+# IDEA artifacts and output dirs
 *.iml
 *.ipr
 *.iws

CONTRIBUTING.md

@@ -120,7 +120,7 @@ source code into your IDE.
 The wiki pages
 [Code Style](https://github.com/spring-projects/spring-framework/wiki/Code-Style) and
 [IntelliJ IDEA Editor Settings](https://github.com/spring-projects/spring-framework/wiki/IntelliJ-IDEA-Editor-Settings)
-define the source file coding standards we use along with some IntelliJ editor settings we customize.
+define the source file coding standards we use along with some IDEA editor settings we customize.
 
 ### Reference Docs
 

README.md

@@ -27,7 +27,7 @@ See the [Build from Source](https://github.com/spring-projects/spring-framework/
 
 ## Continuous Integration Builds
 
-CI builds are defined with [GitHub Actions workflows](.github/workflows).
+Information regarding CI builds can be found in the [Spring Framework Concourse pipeline](ci/README.adoc) documentation.
 
 ## Stay in Touch
 

build.gradle

@@ -6,7 +6,7 @@ plugins {
 	id 'com.github.bjornvester.xjc' version '1.8.2' apply false
 	id 'com.gradleup.shadow' version "9.2.2" apply false
 	id 'me.champeau.jmh' version '0.7.2' apply false
-	id 'io.spring.nullability' version '0.0.9' apply false
+	id 'io.spring.nullability' version '0.0.6' apply false
 }
 
 ext {
@@ -69,15 +69,14 @@ configure([rootProject] + javaProjects) { project ->
 
 	ext.javadocLinks = [
 			"https://docs.oracle.com/en/java/javase/17/docs/api/",
-			//"https://jakarta.ee/specifications/platform/11/apidocs/",
-			"https://docs.hibernate.org/orm/7.2/javadocs/",
+			"https://jakarta.ee/specifications/platform/11/apidocs/",
+			"https://docs.hibernate.org/orm/5.6/javadocs/",
 			"https://www.quartz-scheduler.org/api/2.3.0/",
-			"https://hc.apache.org/httpcomponents-client-5.6.x/current/httpclient5/apidocs/",
-			"https://projectreactor.io/docs/core/release/api/",
+			"https://hc.apache.org/httpcomponents-client-5.5.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
-			"https://docs.junit.org/6.0.2/api/",
-			"https://www.reactive-streams.org/reactive-streams-1.0.4-javadoc/",
+			"https://docs.junit.org/6.0.0/api/",
+			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
 			"https://jspecify.dev/docs/api/"
 	] as String[]

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

@@ -50,7 +50,7 @@ public class CheckstyleConventions {
 			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("13.0.0");
+			checkstyle.setToolVersion("12.0.0");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
 			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();

buildSrc/src/main/java/org/springframework/build/architecture/ArchitectureCheck.java

@@ -49,6 +49,7 @@ import static org.springframework.build.architecture.ArchitectureRules.classesSh
 import static org.springframework.build.architecture.ArchitectureRules.javaClassesShouldNotImportKotlinAnnotations;
 import static org.springframework.build.architecture.ArchitectureRules.noClassesShouldCallStringToLowerCaseWithoutLocale;
 import static org.springframework.build.architecture.ArchitectureRules.noClassesShouldCallStringToUpperCaseWithoutLocale;
+import static org.springframework.build.architecture.ArchitectureRules.packageInfoShouldBeNullMarked;
 
 /**
  * {@link Task} that checks for architecture problems.
@@ -63,7 +64,8 @@ public abstract class ArchitectureCheck extends DefaultTask {
 	public ArchitectureCheck() {
 		getOutputDirectory().convention(getProject().getLayout().getBuildDirectory().dir(getName()));
 		getProhibitObjectsRequireNonNull().convention(true);
-		getRules().addAll(classesShouldNotImportForbiddenTypes(),
+		getRules().addAll(packageInfoShouldBeNullMarked(),
+				classesShouldNotImportForbiddenTypes(),
 				javaClassesShouldNotImportKotlinAnnotations(),
 				allPackagesShouldBeFreeOfTangles(),
 				noClassesShouldCallStringToLowerCaseWithoutLocale(),

buildSrc/src/main/java/org/springframework/build/architecture/ArchitectureRules.java

@@ -46,6 +46,13 @@ abstract class ArchitectureRules {
 				.because("String.toUpperCase(Locale.ROOT) should be used instead");
 	}
 
+	static ArchRule packageInfoShouldBeNullMarked() {
+		return ArchRuleDefinition.classes()
+				.that().haveSimpleName("package-info")
+				.should().beAnnotatedWith("org.jspecify.annotations.NullMarked")
+				.allowEmptyShould(true);
+	}
+
 	static ArchRule classesShouldNotImportForbiddenTypes() {
 		return ArchRuleDefinition.noClasses()
 				.should().dependOnClassesThat()

buildSrc/src/main/java/org/springframework/build/multirelease/MultiReleaseJarPlugin.java

@@ -18,7 +18,6 @@ package org.springframework.build.multirelease;
 
 import javax.inject.Inject;
 
-import org.gradle.api.JavaVersion;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.ConfigurationContainer;
@@ -28,10 +27,6 @@ import org.gradle.api.plugins.ExtensionContainer;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.TaskContainer;
-import org.gradle.api.tasks.TaskProvider;
-import org.gradle.api.tasks.bundling.AbstractArchiveTask;
-import org.gradle.jvm.tasks.Jar;
-import org.gradle.jvm.toolchain.JavaLanguageVersion;
 import org.gradle.jvm.toolchain.JavaToolchainService;
 
 /**
@@ -43,8 +38,6 @@ import org.gradle.jvm.toolchain.JavaToolchainService;
  */
 public class MultiReleaseJarPlugin implements Plugin<Project> {
 
-	public static String VALIDATE_JAR_TASK_NAME = "validateMultiReleaseJar";
-
 	@Inject
 	protected JavaToolchainService getToolchains() {
 		throw new UnsupportedOperationException();
@@ -64,13 +57,5 @@ public class MultiReleaseJarPlugin implements Plugin<Project> {
 				tasks,
 				dependencies,
 				objects);
-
-		if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_25)) {
-			TaskProvider<MultiReleaseJarValidateTask> validateJarTask = tasks.register(VALIDATE_JAR_TASK_NAME, MultiReleaseJarValidateTask.class, (task) -> {
-				task.getJar().set(tasks.named("jar", Jar.class).flatMap(AbstractArchiveTask::getArchiveFile));
-				task.getJavaLauncher().set(task.getJavaToolchainService().launcherFor(spec -> spec.getLanguageVersion().set(JavaLanguageVersion.of(25))));
-			});
-			tasks.named("check", task -> task.dependsOn(validateJarTask));
-		}
 	}
 }

buildSrc/src/main/java/org/springframework/build/multirelease/MultiReleaseJarValidateTask.java

@@ -1,47 +0,0 @@
-/*
- * Copyright 2002-present 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.multirelease;
-
-import org.gradle.api.file.RegularFileProperty;
-import org.gradle.api.tasks.CacheableTask;
-import org.gradle.api.tasks.InputFile;
-import org.gradle.api.tasks.JavaExec;
-import org.gradle.api.tasks.PathSensitive;
-import org.gradle.api.tasks.PathSensitivity;
-import org.gradle.jvm.toolchain.JavaToolchainService;
-
-import java.util.List;
-
-import javax.inject.Inject;
-
-@CacheableTask
-public abstract class MultiReleaseJarValidateTask extends JavaExec {
-
-
-	public MultiReleaseJarValidateTask() {
-		getMainModule().set("jdk.jartool");
-		getArgumentProviders().add(() -> List.of("--validate", "--file", getJar().get().getAsFile().getAbsolutePath()));
-	}
-
-	@Inject
-	protected abstract JavaToolchainService getJavaToolchainService();
-
-	@InputFile
-	@PathSensitive(PathSensitivity.RELATIVE)
-	public abstract RegularFileProperty getJar();
-
-}

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

@@ -78,7 +78,7 @@ public class ShadowSource extends DefaultTask {
 	}
 
 	@OutputDirectory
-	public DirectoryProperty getOutputDirectory() {
+	DirectoryProperty getOutputDirectory() {
 		return this.outputDirectory;
 	}
 

buildSrc/src/test/java/org/springframework/build/multirelease/MultiReleaseJarPluginTests.java

@@ -26,15 +26,11 @@ import java.util.jar.Attributes;
 import java.util.jar.JarFile;
 import org.gradle.testkit.runner.BuildResult;
 import org.gradle.testkit.runner.GradleRunner;
-import org.gradle.testkit.runner.UnexpectedBuildFailure;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.DisabledForJreRange;
-import org.junit.jupiter.api.condition.JRE;
 import org.junit.jupiter.api.io.TempDir;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 /**
  * Tests for {@link MultiReleaseJarPlugin}
@@ -45,13 +41,10 @@ public class MultiReleaseJarPluginTests {
 
 	private File buildFile;
 
-	private File propertiesFile;
-
 	@BeforeEach
 	void setup(@TempDir File projectDir) {
 		this.projectDir = projectDir;
 		this.buildFile = new File(this.projectDir, "build.gradle");
-		this.propertiesFile = new File(this.projectDir, "gradle.properties");
 	}
 
 	@Test
@@ -123,50 +116,12 @@ public class MultiReleaseJarPluginTests {
 		}
 	}
 
-	@Test
-	@DisabledForJreRange(max = JRE.JAVA_24, disabledReason = "'jar --validate' is available as of Java 25")
-	void validateJar() throws IOException {
-		writeBuildFile("""
-				plugins {
-					id 'java'
-					id 'org.springframework.build.multiReleaseJar'
-				}
-				version = '1.2.3'
-				tasks.withType(JavaCompile).configureEach {
-					options.release = 11
-				}
-				multiRelease { releaseVersions 17 }
-				""");
-		writeGradleProperties("""
-				org.gradle.jvmargs=-Duser.language=en
-				""");
-		writeClass("src/main/java17", "Main.java", """
-				public class Main {
-				
-					public void method() {}
-				
-				}
-				""");
-		writeClass("src/main/java", "Main.java", """
-				public class Main {}
-				""");
-		assertThatThrownBy(() ->runGradle("validateMultiReleaseJar"))
-				.isInstanceOf(UnexpectedBuildFailure.class)
-				.hasMessageContaining("entry: META-INF/versions/17/Main.class, contains a class with different api from earlier version");
-	}
-
 	private void writeBuildFile(String buildContent) throws IOException {
 		try (PrintWriter out = new PrintWriter(new FileWriter(this.buildFile))) {
 			out.print(buildContent);
 		}
 	}
 
-	private void writeGradleProperties(String properties) throws IOException {
-		try (PrintWriter out = new PrintWriter(new FileWriter(this.propertiesFile))) {
-			out.print(properties);
-		}
-	}
-
 	private void writeClass(String path, String fileName, String fileContent) throws IOException {
 		Path folder = this.projectDir.toPath().resolve(path);
 		Files.createDirectories(folder);

framework-api/framework-api.gradle

@@ -20,7 +20,6 @@ dependencies {
 	}
 }
 
-def springAspectsOutput = project(":spring-aspects").sourceSets.main.output
 javadoc {
 	javadocTool.set(javaToolchains.javadocToolFor({
 		languageVersion = JavaLanguageVersion.of(25)
@@ -50,7 +49,7 @@ javadoc {
 	doFirst {
 		classpath += files(
 				// ensure the javadoc process can resolve types compiled from .aj sources
-                springAspectsOutput
+				project(":spring-aspects").sourceSets.main.output
 		)
 		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
 	}
@@ -99,9 +98,12 @@ tasks.register('schemaZip', Zip) {
 	moduleProjects.each { module ->
 		def Properties schemas = new Properties();
 
-		module.sourceSets.main.resources.find {
+		def schemaFile = module.sourceSets.main.resources.find {
 			(it.path.endsWith("META-INF/spring.schemas") || it.path.endsWith("META-INF\\spring.schemas"))
-		}?.withInputStream { schemas.load(it) }
+		}
+		if (schemaFile != null) {
+			schemaFile.withInputStream { schemas.load(it) }
+		}
 
 		for (def key : schemas.keySet()) {
 			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')

framework-docs/antora-playbook.yml

@@ -13,9 +13,7 @@ content:
   - url: https://github.com/spring-projects/spring-framework
     # Refname matching:
     # https://docs.antora.org/antora/latest/playbook/content-refname-matching/
-    # branches: We include snapshots for main, 6.2.x, and 7.0.x to 9.*.x.
-    branches: ['main', '6.2.x', '{7..9}.+({0..9}).x']
-    # tags: We effectively include all releases from 6.0.9 to 9.*.*.
+    branches: ['main', '{6..9}.+({1..9}).x']
     tags: ['v{6..9}.+({0..9}).+({0..9})?(-{RC,M}*)', '!(v6.0.{0..8})', '!(v6.0.0-{RC,M}{0..9})']
     start_path: framework-docs
 asciidoc:
@@ -38,4 +36,4 @@ runtime:
     failure_level: warn
 ui:
   bundle:
-    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.25/ui-bundle.zip
+    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.18/ui-bundle.zip

framework-docs/framework-docs.gradle

@@ -70,7 +70,7 @@ dependencies {
 	implementation("com.github.ben-manes.caffeine:caffeine")
 	implementation("com.mchange:c3p0:0.9.5.5")
 	implementation("com.oracle.database.jdbc:ojdbc11")
-	implementation("io.micrometer:context-propagation")
+    implementation("io.micrometer:context-propagation")
 	implementation("io.projectreactor.netty:reactor-netty-http")
 	implementation("jakarta.jms:jakarta.jms-api")
 	implementation("jakarta.servlet:jakarta.servlet-api")
@@ -80,14 +80,12 @@ dependencies {
 	implementation("javax.cache:cache-api")
 	implementation("org.apache.activemq:activemq-ra:6.1.2")
 	implementation("org.apache.commons:commons-dbcp2:2.11.0")
-	implementation("org.apache.groovy:groovy-templates")
 	implementation("org.aspectj:aspectjweaver")
 	implementation("org.assertj:assertj-core")
 	implementation("org.eclipse.jetty.websocket:jetty-websocket-jetty-api")
-	implementation("org.freemarker:freemarker")
 	implementation("org.jetbrains.kotlin:kotlin-stdlib")
-	implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")
-	implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")
 	implementation("org.junit.jupiter:junit-jupiter-api")
 	implementation("tools.jackson.core:jackson-databind")
 	implementation("tools.jackson.dataformat:jackson-dataformat-xml")

framework-docs/modules/ROOT/nav.adoc

@@ -261,6 +261,7 @@
 **** xref:web/websocket/stomp/configuration-performance.adoc[]
 **** xref:web/websocket/stomp/stats.adoc[]
 **** xref:web/websocket/stomp/testing.adoc[]
+** xref:web/integration.adoc[]
 * xref:web-reactive.adoc[]
 ** xref:web/webflux.adoc[]
 *** xref:web/webflux/new-framework.adoc[]
@@ -343,7 +344,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/context-pausing.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[]
@@ -449,13 +449,14 @@
 *** xref:languages/kotlin/null-safety.adoc[]
 *** xref:languages/kotlin/classes-interfaces.adoc[]
 *** xref:languages/kotlin/annotations.adoc[]
-*** xref:languages/kotlin/bean-registration-dsl.adoc[]
+*** xref:languages/kotlin/bean-definition-dsl.adoc[]
 *** xref:languages/kotlin/web.adoc[]
 *** xref:languages/kotlin/coroutines.adoc[]
 *** xref:languages/kotlin/spring-projects-in.adoc[]
 *** xref:languages/kotlin/getting-started.adoc[]
 *** xref:languages/kotlin/resources.adoc[]
 ** xref:languages/groovy.adoc[]
+** xref:languages/dynamic.adoc[]
 * xref:appendix.adoc[]
 * {spring-framework-docs-root}/{spring-version}/javadoc-api/[Java API,window=_blank, role=link-external]
 * {spring-framework-api-kdoc}/[Kotlin API,window=_blank, role=link-external]

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

@@ -124,10 +124,6 @@ on a test class. See xref:testing/annotations/integration-junit-jupiter.adoc#int
 | 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.cache.pause`
-| The pause mode for the context cache in the _Spring TestContext Framework_. See
-xref:testing/testcontext-framework/ctx-management/context-pausing.adoc[Context Pausing].
-
 | `spring.test.context.failure.threshold`
 | The failure threshold for errors encountered while attempting to load an `ApplicationContext`
 in the _Spring TestContext Framework_. See

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

@@ -87,12 +87,14 @@ A crucial difference between Spring pooling and SLSB pooling is that Spring pool
 be applied to any POJO. As with Spring in general, this service can be applied in a
 non-invasive way.
 
-Spring provides support for Commons Pool 2, which provides a
+Spring provides support for Commons Pool 2.2, which provides a
 fairly efficient pooling implementation. You need the `commons-pool` Jar on your
 application's classpath to use this feature. You can also subclass
 `org.springframework.aop.target.AbstractPoolingTargetSource` to support any other
 pooling API.
 
+NOTE: Commons Pool 1.5+ is also supported but is deprecated as of Spring Framework 4.2.
+
 The following listing shows an example configuration:
 
 [source,xml,indent=0,subs="verbatim,quotes"]

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

@@ -104,7 +104,7 @@ Note that pointcut definitions are generally matched against any intercepted met
 If a pointcut is strictly meant to be public-only, even in a CGLIB proxy scenario with
 potential non-public interactions through proxies, it needs to be defined accordingly.
 
-If your interception needs to include method calls or even constructors within the target
+If your interception needs include method calls or even constructors within the target
 class, consider the use of Spring-driven xref:core/aop/using-aspectj.adoc#aop-aj-ltw[native AspectJ weaving] instead
 of Spring's proxy-based AOP framework. This constitutes a different mode of AOP usage
 with different characteristics, so be sure to make yourself familiar with weaving

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

@@ -239,6 +239,40 @@ The namespace itself provides the import directive feature. Further
 configuration features beyond plain bean definitions are available in a selection
 of XML namespaces provided by Spring -- for example, the `context` and `util` namespaces.
 
+[[beans-factory-groovy]]
+=== The Groovy Bean Definition DSL
+
+As a further example for externalized configuration metadata, bean definitions can also
+be expressed in Spring's Groovy Bean Definition DSL, as known from the Grails framework.
+Typically, such configuration live in a ".groovy" file with the structure shown in the
+following example:
+
+[source,groovy,indent=0,subs="verbatim,quotes"]
+----
+	beans {
+		dataSource(BasicDataSource) {
+			driverClassName = "org.hsqldb.jdbcDriver"
+			url = "jdbc:hsqldb:mem:grailsDB"
+			username = "sa"
+			password = ""
+			settings = [mynew:"setting"]
+		}
+		sessionFactory(SessionFactory) {
+			dataSource = dataSource
+		}
+		myService(MyService) {
+			nestedBean = { AnotherBean bean ->
+				dataSource = dataSource
+			}
+		}
+	}
+----
+
+This configuration style is largely equivalent to XML bean definitions and even
+supports Spring's XML configuration namespaces. It also allows for importing XML
+bean definition files through an `importBeans` directive.
+
+
 [[beans-factory-client]]
 == Using the Container
 

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

@@ -1045,10 +1045,10 @@ methods anywhere. However, regular `@Bean` methods in `@Configuration` classes n
 to be overridable -- that is, they must not be declared as `private` or `final`.
 
 `@Bean` methods are also discovered on base classes of a given component or
-configuration class, as well as on Java default methods declared in interfaces
+configuration class, as well as on Java 8 default methods declared in interfaces
 implemented by the component or configuration class. This allows for a lot of
 flexibility in composing complex configuration arrangements, with even multiple
-inheritance being possible through Java default methods.
+inheritance being possible through Java 8 default methods as of Spring 4.2.
 
 Finally, a single class may hold multiple `@Bean` methods for the same
 bean, as an arrangement of multiple factory methods to use depending on available

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

@@ -99,7 +99,7 @@ the `@Bean` factory method in favor of any pre-declared constructor on the bean
 ****
 
 NOTE: We acknowledge that overriding beans in test scenarios is convenient, and there is
-explicit support for this. Please refer to
+explicit support for this as of Spring Framework 6.2. Please refer to
 xref:testing/testcontext-framework/bean-overriding.adoc[this section] for more details.
 
 

framework-docs/modules/ROOT/pages/core/beans/dependencies/factory-properties-detailed.adoc

@@ -50,8 +50,9 @@ XML configuration:
 
 The preceding XML is more succinct. However, typos are discovered at runtime rather than
 design time, unless you use an IDE (such as https://www.jetbrains.com/idea/[IntelliJ
-IDEA] or the {spring-site-tools}[Spring Tools]) that supports automatic property
-completion when you create bean definitions. Such IDE assistance is highly recommended.
+IDEA] or the {spring-site-tools}[Spring Tools for Eclipse])
+that supports automatic property completion when you create bean definitions. Such IDE
+assistance is highly recommended.
 
 You can also configure a `java.util.Properties` instance, as follows:
 

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

@@ -194,7 +194,8 @@ The following `beans` element uses the `InstantiationTracingBeanPostProcessor`:
 Notice how the `InstantiationTracingBeanPostProcessor` is merely defined. It does not
 even have a name, and, because it is a bean, it can be dependency-injected as you would any
 other bean. (The preceding configuration also defines a bean that is backed by a Groovy
-script.)
+script. The Spring dynamic language support is detailed in the chapter entitled
+xref:languages/dynamic.adoc[Dynamic Language Support].)
 
 The following Java application runs the preceding code and configuration:
 

framework-docs/modules/ROOT/pages/core/beans/java/composing-configuration-classes.adoc

@@ -327,8 +327,9 @@ Kotlin::
 ----
 ======
 
-TIP: Note that there is no need to specify `@Autowired` if the target bean defines
-only one constructor.
+TIP: Constructor injection in `@Configuration` classes is only supported as of Spring
+Framework 4.3. Note also that there is no need to specify `@Autowired` if the target
+bean defines only one constructor.
 
 [discrete]
 [[beans-java-injecting-imported-beans-fq]]
@@ -338,11 +339,11 @@ In the preceding scenario, using `@Autowired` works well and provides the desire
 modularity, but determining exactly where the autowired bean definitions are declared is
 still somewhat ambiguous. For example, as a developer looking at `ServiceConfig`, how do
 you know exactly where the `@Autowired AccountRepository` bean is declared? It is not
-explicit in the code, and this may be just fine. Note that the
-{spring-site-tools}[Spring Tools] IDE support provides tooling that can render graphs
-showing how everything is wired, which may be all you need. Also, your Java IDE can
-easily find all declarations and uses of the `AccountRepository` type and quickly show
-you the location of `@Bean` methods that return that type.
+explicit in the code, and this may be just fine. Remember that the
+{spring-site-tools}[Spring Tools for Eclipse] provides tooling that
+can render graphs showing how everything is wired, which may be all you need. Also,
+your Java IDE can easily find all declarations and uses of the `AccountRepository` type
+and quickly show you the location of `@Bean` methods that return that type.
 
 In cases where this ambiguity is not acceptable and you wish to have direct navigation
 from within your IDE from one `@Configuration` class to another, consider autowiring the

framework-docs/modules/ROOT/pages/core/beans/java/programmatic-bean-registration.adoc

@@ -9,7 +9,28 @@ efficient way.
 Those bean registrar implementations are typically imported with an `@Import` annotation
 on `@Configuration` classes.
 
-include-code::./MyConfiguration[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+     @Configuration
+     @Import(MyBeanRegistrar.class)
+     class MyConfiguration {
+     }
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+    @Configuration
+    @Import(MyBeanRegistrar::class)
+    class MyConfiguration {
+    }
+----
+======
 
 NOTE: You can leverage type-level conditional annotations ({spring-framework-api}/context/annotation/Conditional.html[`@Conditional`],
 but also other variants) to conditionally import the related bean registrars.
@@ -19,7 +40,49 @@ The bean registrar implementation uses {spring-framework-api}/beans/factory/Bean
 and flexible way. For example, it allows custom registration through an `if` expression, a
 `for` loop, etc.
 
-include-code::./MyBeanRegistrar[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+    class MyBeanRegistrar implements BeanRegistrar {
+
+        @Override
+        public void register(BeanRegistry registry, Environment env) {
+            registry.registerBean("foo", Foo.class);
+            registry.registerBean("bar", Bar.class, spec -> spec
+                    .prototype()
+                    .lazyInit()
+                    .description("Custom description")
+                    .supplier(context -> new Bar(context.bean(Foo.class))));
+            if (env.matchesProfiles("baz")) {
+                registry.registerBean(Baz.class, spec -> spec
+                        .supplier(context -> new Baz("Hello World!")));
+            }
+        }
+    }
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+    class MyBeanRegistrar : BeanRegistrarDsl({
+        registerBean<Foo>()
+        registerBean(
+            name = "bar",
+            prototype = true,
+            lazyInit = true,
+            description = "Custom description") {
+                Bar(bean<Foo>())
+        }
+        profile("baz") {
+            registerBean { Baz("Hello World!") }
+        }
+    })
+----
+======
 
 NOTE: Bean registrars are supported with xref:core/aot.adoc[Ahead of Time Optimizations],
 either on the JVM or with GraalVM native images, including when instance suppliers are used.

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

@@ -7,14 +7,14 @@ similar to the https://jakarta.ee/specifications/expression-language/[Jakarta Ex
 Language] but offers additional features, most notably method invocation and basic string
 templating functionality.
 
-While there are several other Java expression languages available -- OGNL, MVEL, and
-JBoss EL, to name a few -- the Spring Expression Language was created to provide the
-Spring community with a single well supported expression language that can be used across
-all the products in the Spring portfolio. Its language features are driven by the
-requirements of the projects in the Spring portfolio, including tooling requirements for
-code completion within the {spring-site-tools}[Spring Tools] IDE support. That said, SpEL
-is based on a technology-agnostic API that lets other expression language implementations
-be integrated, should the need arise.
+While there are several other Java expression languages available -- OGNL, MVEL, and JBoss
+EL, to name a few -- the Spring Expression Language was created to provide the Spring
+community with a single well supported expression language that can be used across all
+the products in the Spring portfolio. Its language features are driven by the
+requirements of the projects in the Spring portfolio, including tooling requirements
+for code completion support within the {spring-site-tools}[Spring Tools for Eclipse].
+That said, SpEL is based on a technology-agnostic API that lets other expression language
+implementations be integrated, should the need arise.
 
 While SpEL serves as the foundation for expression evaluation within the Spring
 portfolio, it is not directly tied to Spring and can be used independently. To

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

@@ -6,7 +6,7 @@ are set by using the `setVariable()` method in `EvaluationContext` implementatio
 
 [NOTE]
 ====
-Variable names must begin with a letter (as defined below), an underscore, or a dollar
+Variable names must be begin with a letter (as defined below), an underscore, or a dollar
 sign.
 
 Variable names must be composed of one or more of the following supported types of

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

@@ -23,19 +23,8 @@ public void sendNotification() {
 }
 ----
 
-By default, the method invocation will be retried for any exception thrown: with at most
-3 retry attempts (`maxRetries = 3`) after an initial failure, and a delay of 1 second
-between attempts.
-
-[NOTE]
-====
-A `@Retryable` method will be invoked at least once and retried at most `maxRetries`
-times, where `maxRetries` is the maximum number of retry attempts. Specifically,
-`total attempts = 1 initial attempt + maxRetries attempts`.
-
-For example, if `maxRetries` is set to `4`, the `@Retryable` method will be invoked at
-least once and at most 5 times.
-====
+By default, the method invocation will be retried for any exception thrown: with at most 3
+retry attempts after an initial failure, and a delay of 1 second between attempts.
 
 This can be specifically adapted for every method if necessary — for example, by narrowing
 the exceptions to retry via the `includes` and `excludes` attributes. The supplied
@@ -64,13 +53,13 @@ Custom predicates can be combined with `includes` and `excludes`; however, custo
 predicates will always be applied after `includes` and `excludes` have been applied.
 ====
 
-Or for 4 retry attempts and an exponential back-off strategy with a bit of jitter:
+Or for 5 retry attempts and an exponential back-off strategy with a bit of jitter:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 @Retryable(
   includes = MessageDeliveryException.class,
-  maxRetries = 4,
+  maxAttempts = 5,
   delay = 100,
   jitter = 10,
   multiplier = 2,
@@ -85,7 +74,7 @@ type, decorating the pipeline with Reactor's retry capabilities:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-@Retryable(maxRetries = 4, delay = 100)
+@Retryable(maxAttempts = 5, delay = 100)
 public Mono<Void> sendNotification() {
     return Mono.from(...); // <1>
 }
@@ -179,31 +168,20 @@ configured {spring-framework-api}/core/retry/RetryPolicy.html[`RetryPolicy`].
 ----
 <1> Implicitly uses `RetryPolicy.withDefaults()`.
 
-By default, a retryable operation will be retried for any exception thrown: with at most
-3 retry attempts (`maxRetries = 3`) after an initial failure, and a delay of 1 second
-between attempts.
+By default, a retryable operation will be retried for any exception thrown: with at most 3
+retry attempts after an initial failure, and a delay of 1 second between attempts.
 
 If you only need to customize the number of retry attempts, you can use the
-`RetryPolicy.withMaxRetries()` factory method as demonstrated below.
-
-[NOTE]
-====
-A retryable operation will be executed at least once and retried at most `maxRetries`
-times, where `maxRetries` is the maximum number of retry attempts. Specifically,
-`total attempts = 1 initial attempt + maxRetries attempts`.
-
-For example, if `maxRetries` is set to `4`, the retryable operation will be invoked at
-least once and at most 5 times.
-====
+`RetryPolicy.withMaxAttempts()` factory method as demonstrated below.
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-    var retryTemplate = new RetryTemplate(RetryPolicy.withMaxRetries(4)); // <1>
+    var retryTemplate = new RetryTemplate(RetryPolicy.withMaxAttempts(5)); // <1>
 
     retryTemplate.execute(
             () -> jmsClient.destination("notifications").send(...));
 ----
-<1> Explicitly uses `RetryPolicy.withMaxRetries(4)`.
+<1> Explicitly uses `RetryPolicy.withMaxAttempts(5)`.
 
 If you need to narrow the types of exceptions to retry, that can be achieved via the
 `includes()` and `excludes()` builder methods. The supplied exception types will be
@@ -235,14 +213,14 @@ Custom predicates can be combined with `includes` and `excludes`; however, custo
 predicates will always be applied after `includes` and `excludes` have been applied.
 ====
 
-The following example demonstrates how to configure a `RetryPolicy` with 4 retry attempts
+The following example demonstrates how to configure a `RetryPolicy` with 5 retry attempts
 and an exponential back-off strategy with a bit of jitter.
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
     var retryPolicy = RetryPolicy.builder()
             .includes(MessageDeliveryException.class)
-            .maxRetries(4)
+            .maxAttempts(5)
             .delay(Duration.ofMillis(100))
             .jitter(Duration.ofMillis(10))
             .multiplier(2)

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

@@ -676,7 +676,7 @@ provides `firstName` and `lastName` properties, such as the `Actor` class from a
 [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"))
+			.paramSource(new Actor("Leonor", "Watling")
 			.update();
 ----
 

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

@@ -15,7 +15,7 @@ configuration options. You should instantiate the `SimpleJdbcInsert` in the data
 layer's initialization method. For this example, the initializing method is the
 `setDataSource` method. You do not need to subclass the `SimpleJdbcInsert` class. Instead,
 you can create a new instance and set the table name by using the `withTableName` method.
-Configuration methods for this class follow the `fluent` style that returns the instance
+Configuration methods for this class follow the `fluid` style that returns the instance
 of the `SimpleJdbcInsert`, which lets you chain all configuration methods. The following
 example uses only one configuration method (we show examples of multiple methods later):
 
@@ -349,11 +349,11 @@ parameters return the data read from the table.
 
 You can declare `SimpleJdbcCall` in a manner similar to declaring `SimpleJdbcInsert`. You
 should instantiate and configure the class in the initialization method of your data-access
-layer. In contrast to the `StoredProcedure` class, you do not need to create a subclass,
-and you do not need to declare parameters that can be looked up in the database metadata.
-The following `SimpleJdbcCall` configuration example uses the preceding stored procedure.
-The only configuration option (other than the `DataSource`) is the name of the stored
-procedure.
+layer. Compared to the `StoredProcedure` class, you need not create a subclass
+and you need not to declare parameters that can be looked up in the database metadata.
+The following example of a `SimpleJdbcCall` configuration uses the preceding stored
+procedure (the only configuration option, in addition to the `DataSource`, is the name
+of the stored procedure):
 
 [tabs]
 ======

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

@@ -3,22 +3,21 @@
 :page-aliases: integration/class-data-sharing.adoc
 :page-aliases: integration/cds.adoc
 
-The ahead-of-time cache is a JVM feature introduced in Java 24 via
+The ahead-of-time cache is a JVM feature introduced in Java 24 via the
 https://openjdk.org/jeps/483[JEP 483] that can help reduce the startup time and memory
-footprint of Java applications. AOT cache is a natural evolution of
-https://docs.oracle.com/en/java/javase/17/vm/class-data-sharing.html[Class Data Sharing (CDS)].
+footprint of Java applications. AOT cache is a natural evolution of https://docs.oracle.com/en/java/javase/17/vm/class-data-sharing.html[Class Data Sharing (CDS)].
 Spring Framework supports both CDS and AOT cache, and it is recommended that you use the
-latter if available in the JVM version you are using (Java 24+).
+later if available in the JVM version your are using (Java 24+).
 
 To use this feature, an AOT cache should be created for the particular classpath of the
 application. It is possible to create this cache on the deployed instance, or during a
-training run performed for example when packaging the application thanks to a hook-point
+training run performed for example when packaging the application thanks to an hook-point
 provided by the Spring Framework to ease such use case. Once the cache is available, users
 should opt in to use it via a JVM flag.
 
 NOTE: If you are using Spring Boot, it is highly recommended to leverage its
 {spring-boot-docs-ref}/packaging/efficient.html#packaging.efficient.unpacking[executable JAR unpacking support]
-which is designed to fulfill the class loading requirements of both the AOT cache and CDS.
+which is designed to fulfill the class loading requirements of both AOT cache and CDS.
 
 == Creating the cache
 
@@ -30,22 +29,14 @@ invoked; but the lifecycle has not started, and the `ContextRefreshedEvent` has
 been published.
 
 To create the cache during the training run, it is possible to specify the `-Dspring.context.exit=onRefresh`
-JVM flag to start and then exit your Spring application once the
+JVM flag to start then exit your Spring application once the
 `ApplicationContext` has refreshed:
 
 
 --
 [tabs]
 ======
-
-AOT cache (Java 25+)::
-+
-[source,bash,subs="verbatim,quotes"]
-----
-java -XX:AOTCacheOutput=app.aot -Dspring.context.exit=onRefresh -jar application.jar ...
-----
-
-AOT cache (Java 24)::
+AOT cache::
 +
 [source,bash,subs="verbatim,quotes"]
 ----
@@ -64,12 +55,6 @@ java -XX:ArchiveClassesAtExit=app.jsa -Dspring.context.exit=onRefresh ...
 ======
 --
 
-NOTE: With Java 25+, AOT cache stores, among other things, the
-https://openjdk.org/jeps/515[method profiling information]. Therefore, to benefit of this capability,
-it is recommended to create an AOT cache for an application that experienced a portion of a
-production-like workflow instead of using the `-Dspring.context.exit=onRefresh` flag which designed to
-optimize only the startup of your application.
-
 == Using the cache
 
 Once the cache file has been created, you can use it to start your application faster:
@@ -97,7 +82,7 @@ java -XX:SharedArchiveFile=app.jsa ...
 
 Pay attention to the logs and the startup time to check if the AOT cache is used successfully.
 To figure out how effective the cache is, you can enable class loading logs by adding
-an extra attribute: `-Xlog:class+load:file=aot-cache.log`. This creates an `aot-cache.log` with
+an extra attribute: `-Xlog:class+load:file=aot-cache.log`. This creates a `aot-cache.log` with
 every attempt to load a class and its source. Classes that are loaded from the cache should have
 a "shared objects file" source, as shown in the following example:
 
@@ -110,11 +95,11 @@ a "shared objects file" source, as shown in the following example:
 [0.151s][info][class,load] org.springframework.context.MessageSource source: shared objects file
 ----
 
-If the AOT cache cannot be enabled or if you have a large number of classes that are not loaded from
+If the AOT cache can't be enabled or if you have a large number of classes that are not loaded from
 the cache, make sure that the following conditions are fulfilled when creating and using the cache:
 
  - The very same JVM must be used.
  - The classpath must be specified as a JAR or a list of JARs, and avoid the usage of directories and `*` wildcard characters.
  - The timestamps of the JARs must be preserved.
- - When using the cache, the classpath must be the same as the one used to create it, in the same order.
-Additional JARs or directories can be specified *at the end* (but will not be cached).
+ - When using the cache, the classpath must be the same than the one used to create it, in the same order.
+Additional JARs or directories can be specified *at the end* (but won't be cached).

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

@@ -1,11 +1,16 @@
 [[appendix]]
 = Appendix
 
+
+
+
 [[appendix.xsd-schemas]]
 == XML Schemas
 
 This part of the appendix lists XML schemas related to integration technologies.
 
+
+
 [[appendix.xsd-schemas-jee]]
 === The `jee` Schema
 
@@ -167,7 +172,7 @@ different properties with `jee`:
 
 The `<jee:local-slsb/>` element configures a reference to a local EJB Stateless Session Bean.
 
-The following example shows how to configure a reference to a local EJB Stateless Session Bean
+The following example shows how to configures a reference to a local EJB Stateless Session Bean
 without `jee`:
 
 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -179,7 +184,7 @@ without `jee`:
 	</bean>
 ----
 
-The following example shows how to configure a reference to a local EJB Stateless Session Bean
+The following example shows how to configures a reference to a local EJB Stateless Session Bean
 with `jee`:
 
 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -195,7 +200,7 @@ with `jee`:
 
 The `<jee:local-slsb/>` element configures a reference to a local EJB Stateless Session Bean.
 
-The following example shows how to configure a reference to a local EJB Stateless Session Bean
+The following example shows how to configures a reference to a local EJB Stateless Session Bean
 and a number of properties without `jee`:
 
 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -210,7 +215,7 @@ and a number of properties without `jee`:
 	</bean>
 ----
 
-The following example shows how to configure a reference to a local EJB Stateless Session Bean
+The following example shows how to configures a reference to a local EJB Stateless Session Bean
 and a number of properties with `jee`:
 
 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -229,7 +234,7 @@ and a number of properties with `jee`:
 
 The `<jee:remote-slsb/>` element configures a reference to a `remote` EJB Stateless Session Bean.
 
-The following example shows how to configure a reference to a remote EJB Stateless Session Bean
+The following example shows how to configures a reference to a remote EJB Stateless Session Bean
 without `jee`:
 
 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -246,7 +251,7 @@ without `jee`:
 	</bean>
 ----
 
-The following example shows how to configure a reference to a remote EJB Stateless Session Bean
+The following example shows how to configures a reference to a remote EJB Stateless Session Bean
 with `jee`:
 
 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -308,7 +313,7 @@ xref:integration/jmx/naming.adoc#jmx-context-mbeanexport[Configuring Annotation-
 === The `cache` Schema
 
 You can use the `cache` elements to enable support for Spring's `@CacheEvict`, `@CachePut`,
-and `@Caching` annotations. The `cache` schema also supports declarative XML-based caching. See
+and `@Caching` annotations. It it also supports declarative XML-based caching. See
 xref:integration/cache/annotations.adoc#cache-annotation-enable[Enabling Caching Annotations] and
 xref:integration/cache/declarative-xml.adoc[Declarative XML-based Caching] for details.
 

framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

@@ -5,7 +5,7 @@ The Spring Framework provides the following choices for making calls to REST end
 
 * xref:integration/rest-clients.adoc#rest-restclient[`RestClient`] -- synchronous client with a fluent API
 * xref:integration/rest-clients.adoc#rest-webclient[`WebClient`] -- non-blocking, reactive client with fluent API
-* xref:integration/rest-clients.adoc#rest-resttemplate[`RestTemplate`] -- synchronous client with template method API, now deprecated in favor of `RestClient`
+* xref:integration/rest-clients.adoc#rest-resttemplate[`RestTemplate`] -- synchronous client with template method API
 * xref:integration/rest-clients.adoc#rest-http-service-client[HTTP Service Clients] -- annotated interface backed by generated proxy
 
 
@@ -479,8 +479,7 @@ See xref:web/webflux-webclient.adoc[WebClient] for more details.
 The `RestTemplate` provides a high-level API over HTTP client libraries in the form of a classic Spring Template class.
 It exposes the following groups of overloaded methods:
 
-WARNING: As of Spring Framework 7.0, `RestTemplate` is deprecated in favor of `RestClient` and will be removed in a future version,
-please use the xref:integration/rest-clients.adoc#migrating-to-restclient["Migrating to RestClient"] guide.
+NOTE: The xref:integration/rest-clients.adoc#rest-restclient[`RestClient`] offers a more modern API for synchronous HTTP access.
 For asynchronous and streaming scenarios, consider the reactive xref:web/webflux-webclient.adoc[WebClient].
 
 [[rest-overview-of-resttemplate-methods-tbl]]
@@ -548,26 +547,10 @@ See the xref:integration/observability.adoc#http-client.resttemplate[RestTemplat
 Objects passed into and returned from `RestTemplate` methods are converted to and from HTTP messages
 with the help of an `HttpMessageConverter`, see <<rest-message-conversion>>.
 
-[[migrating-to-restclient]]
-=== Migrating to `RestClient`
-
-Applications can adopt `RestClient` in a gradual fashion, first focusing on API usage and then on infrastructure setup.
-You can consider the following steps:
-
-1. Create one or more `RestClient` from existing `RestTemplate` instances, like: `RestClient restClient = RestClient.create(restTemplate)`.
-  Gradually replace `RestTemplate` usage in your application, component by component, by focusing first on issuing requests.
-  See the table below for API equivalents.
-2. Once all client requests go through `RestClient` instances, you can now work on replicating your existing
-  `RestTemplate` instance creations by using `RestClient.Builder`. Because `RestTemplate` and `RestClient`
-  share the same infrastructure, you can reuse custom `ClientHttpRequestFactory` or `ClientHttpRequestInterceptor`
-  in your setup. See xref:integration/rest-clients.adoc#rest-restclient[the `RestClient` builder API].
-
-If no other library is available on the classpath, `RestClient` will choose the `JdkClientHttpRequestFactory`
-powered by the modern JDK `HttpClient`, whereas `RestTemplate` would pick the `SimpleClientHttpRequestFactory` that
-uses `HttpURLConnection`. This can explain subtle behavior difference at runtime at the HTTP level.
-
+=== Migrating from `RestTemplate` to `RestClient`
 
 The following table shows `RestClient` equivalents for `RestTemplate` methods.
+It can be used to migrate from the latter to the former.
 
 .RestClient equivalents for RestTemplate methods
 [cols="1,1", options="header"]
@@ -871,11 +854,6 @@ The following table shows `RestClient` equivalents for `RestTemplate` methods.
 
 |===
 
-`RestClient` and `RestTemplate` instances share the same behavior when it comes to throwing exceptions
-(with the `RestClientException` type being at the top of the hierarchy).
-When `RestTemplate` consistently throws `HttpClientErrorException` for "4xx" response statues,
-`RestClient` allows for more flexibility with custom xref:integration/rest-clients.adoc#rest-http-service-client-exceptions["status handlers"].
-
 
 [[rest-http-service-client]]
 == HTTP Service Clients

framework-docs/modules/ROOT/pages/languages/dynamic.adoc

@@ -0,0 +1,831 @@
+[[dynamic-language]]
+= Dynamic Language Support
+
+Spring provides comprehensive support for using classes and objects that have been
+defined by using a dynamic language (such as Groovy) with Spring. This support lets
+you write any number of classes in a supported dynamic language and have the Spring
+container transparently instantiate, configure, and dependency inject the resulting
+objects.
+
+Spring's scripting support primarily targets Groovy and BeanShell. Beyond those
+specifically supported languages, the JSR-223 scripting mechanism is supported
+for integration with any JSR-223 capable language provider (as of Spring 4.2),
+for example, JRuby.
+
+You can find fully working examples of where this dynamic language support can be
+immediately useful in xref:languages/dynamic.adoc#dynamic-language-scenarios[Scenarios].
+
+
+[[dynamic-language-a-first-example]]
+== A First Example
+
+The bulk of this chapter is concerned with describing the dynamic language support in
+detail. Before diving into all of the ins and outs of the dynamic language support,
+we look at a quick example of a bean defined in a dynamic language. The dynamic
+language for this first bean is Groovy. (The basis of this example was taken from the
+Spring test suite. If you want to see equivalent examples in any of the other
+supported languages, take a look at the source code).
+
+The next example shows the `Messenger` interface, which the Groovy bean is going to
+implement. Note that this interface is defined in plain Java. Dependent objects that
+are injected with a reference to the `Messenger` do not know that the underlying
+implementation is a Groovy script. The following listing shows the `Messenger` interface:
+
+[source,java,indent=0,subs="verbatim,quotes",chomp="-packages"]
+----
+	package org.springframework.scripting;
+
+	public interface Messenger {
+
+		String getMessage();
+	}
+----
+
+The following example defines a class that has a dependency on the `Messenger` interface:
+
+[source,java,indent=0,subs="verbatim,quotes",chomp="-packages"]
+----
+	package org.springframework.scripting;
+
+	public class DefaultBookingService implements BookingService {
+
+		private Messenger messenger;
+
+		public void setMessenger(Messenger messenger) {
+			this.messenger = messenger;
+		}
+
+		public void processBooking() {
+			// use the injected Messenger object...
+		}
+	}
+----
+
+The following example implements the `Messenger` interface in Groovy:
+
+[source,groovy,indent=0,subs="verbatim,quotes",chomp="-packages",fold="none"]
+----
+	package org.springframework.scripting.groovy
+
+	// Import the Messenger interface (written in Java) that is to be implemented
+	import org.springframework.scripting.Messenger
+
+	// Define the implementation in Groovy in file 'Messenger.groovy'
+	class GroovyMessenger implements Messenger {
+
+		String message
+	}
+----
+
+[NOTE]
+====
+To use the custom dynamic language tags to define dynamic-language-backed beans, you
+need to have the XML Schema preamble at the top of your Spring XML configuration file.
+You also need to use a Spring `ApplicationContext` implementation as your IoC
+container. Using the dynamic-language-backed beans with a plain `BeanFactory`
+implementation is supported, but you have to manage the plumbing of the Spring internals
+to do so.
+
+For more information on schema-based configuration, see xref:languages/dynamic.adoc#xsd-schemas-lang[XML Schema-based Configuration]
+.
+====
+
+Finally, the following example shows the bean definitions that effect the injection of the
+Groovy-defined `Messenger` implementation into an instance of the
+`DefaultBookingService` class:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<?xml version="1.0" encoding="UTF-8"?>
+	<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:lang="http://www.springframework.org/schema/lang"
+		xsi:schemaLocation="
+			http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
+			http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">
+
+		<!-- this is the bean definition for the Groovy-backed Messenger implementation -->
+		<lang:groovy id="messenger" script-source="classpath:Messenger.groovy">
+			<lang:property name="message" value="I Can Do The Frug" />
+		</lang:groovy>
+
+		<!-- an otherwise normal bean that will be injected by the Groovy-backed Messenger -->
+		<bean id="bookingService" class="x.y.DefaultBookingService">
+			<property name="messenger" ref="messenger" />
+		</bean>
+
+	</beans>
+----
+
+The `bookingService` bean (a `DefaultBookingService`) can now use its private `messenger`
+member variable as normal, because the `Messenger` instance that was injected into it is
+a `Messenger` instance. There is nothing special going on here -- just plain Java and
+plain Groovy.
+
+Hopefully, the preceding XML snippet is self-explanatory, but do not worry unduly if it is not.
+Keep reading for the in-depth detail on the whys and wherefores of the preceding configuration.
+
+
+[[dynamic-language-beans]]
+== Defining Beans that Are Backed by Dynamic Languages
+
+This section describes exactly how you define Spring-managed beans in any of the
+supported dynamic languages.
+
+Note that this chapter does not attempt to explain the syntax and idioms of the supported
+dynamic languages. For example, if you want to use Groovy to write certain of the classes
+in your application, we assume that you already know Groovy. If you need further details
+about the dynamic languages themselves, see
+xref:languages/dynamic.adoc#dynamic-language-resources[Further Resources] at the end of
+this chapter.
+
+[[dynamic-language-beans-concepts]]
+=== Common Concepts
+
+The steps involved in using dynamic-language-backed beans are as follows:
+
+. Write the test for the dynamic language source code (naturally).
+. Then write the dynamic language source code itself.
+. Define your dynamic-language-backed beans by using the appropriate `<lang:language/>`
+  element in the XML configuration (you can define such beans programmatically by
+  using the Spring API, although you will have to consult the source code for
+  directions on how to do this, as this chapter does not cover this type of advanced configuration).
+  Note that this is an iterative step. You need at least one bean definition for each dynamic
+  language source file (although multiple bean definitions can reference the same source file).
+
+The first two steps (testing and writing your dynamic language source files) are beyond
+the scope of this chapter. See the language specification and reference manual
+for your chosen dynamic language and crack on with developing your dynamic language
+source files. You first want to read the rest of this chapter, though, as
+Spring's dynamic language support does make some (small) assumptions about the contents
+of your dynamic language source files.
+
+[[dynamic-language-beans-concepts-xml-language-element]]
+==== The <lang:language/> element
+
+The final step in the list in the xref:languages/dynamic.adoc#dynamic-language-beans-concepts[preceding section]
+involves defining dynamic-language-backed bean definitions, one for each bean that you
+want to configure (this is no different from normal JavaBean configuration). However,
+instead of specifying the fully qualified class name of the class that is to be
+instantiated and configured by the container, you can use the `<lang:language/>`
+element to define the dynamic language-backed bean.
+
+Each of the supported languages has a corresponding `<lang:language/>` element:
+
+* `<lang:groovy/>` (Groovy)
+* `<lang:bsh/>` (BeanShell)
+* `<lang:std/>` (JSR-223, for example, with JRuby)
+
+The exact attributes and child elements that are available for configuration depends on
+exactly which language the bean has been defined in (the language-specific sections
+later in this chapter detail this).
+
+[[dynamic-language-refreshable-beans]]
+==== Refreshable Beans
+
+One of the (and perhaps the single) most compelling value adds of the dynamic language
+support in Spring is the "`refreshable bean`" feature.
+
+A refreshable bean is a dynamic-language-backed bean. With a small amount of
+configuration, a dynamic-language-backed bean can monitor changes in its underlying
+source file resource and then reload itself when the dynamic language source file is
+changed (for example, when you edit and save changes to the file on the file system).
+
+This lets you deploy any number of dynamic language source files as part of an
+application, configure the Spring container to create beans backed by dynamic
+language source files (using the mechanisms described in this chapter), and (later,
+as requirements change or some other external factor comes into play) edit a dynamic
+language source file and have any change they make be reflected in the bean that is
+backed by the changed dynamic language source file. There is no need to shut down a
+running application (or redeploy in the case of a web application). The
+dynamic-language-backed bean so amended picks up the new state and logic from the
+changed dynamic language source file.
+
+NOTE: This feature is off by default.
+
+Now we can take a look at an example to see how easy it is to start using refreshable
+beans. To turn on the refreshable beans feature, you have to specify exactly one
+additional attribute on the `<lang:language/>` element of your bean definition. So,
+if we stick with xref:languages/dynamic.adoc#dynamic-language-a-first-example[the example] from earlier in
+this chapter, the following example shows what we would change in the Spring XML
+configuration to effect refreshable beans:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<beans>
+
+		<!-- this bean is now 'refreshable' due to the presence of the 'refresh-check-delay' attribute -->
+		<lang:groovy id="messenger"
+				refresh-check-delay="5000" <!-- switches refreshing on with 5 seconds between checks -->
+				script-source="classpath:Messenger.groovy">
+			<lang:property name="message" value="I Can Do The Frug" />
+		</lang:groovy>
+
+		<bean id="bookingService" class="x.y.DefaultBookingService">
+			<property name="messenger" ref="messenger" />
+		</bean>
+
+	</beans>
+----
+
+That really is all you have to do. The `refresh-check-delay` attribute defined on the
+`messenger` bean definition is the number of milliseconds after which the bean is
+refreshed with any changes made to the underlying dynamic language source file.
+You can turn off the refresh behavior by assigning a negative value to the
+`refresh-check-delay` attribute. Remember that, by default, the refresh behavior is
+disabled. If you do not want the refresh behavior, do not define the attribute.
+
+If we then run the following application, we can exercise the refreshable feature.
+(Please excuse the "`jumping-through-hoops-to-pause-the-execution`" shenanigans
+in this next slice of code.) The `System.in.read()` call is only there so that the
+execution of the program pauses while you (the developer in this scenario) go off
+and edit the underlying dynamic language source file so that the refresh triggers
+on the dynamic-language-backed bean when the program resumes execution.
+
+The following listing shows this sample application:
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	import org.springframework.context.ApplicationContext;
+	import org.springframework.context.support.ClassPathXmlApplicationContext;
+	import org.springframework.scripting.Messenger;
+
+	public final class Boot {
+
+		public static void main(final String[] args) throws Exception {
+			ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
+			Messenger messenger = (Messenger) ctx.getBean("messenger");
+			System.out.println(messenger.getMessage());
+			// pause execution while I go off and make changes to the source file...
+			System.in.read();
+			System.out.println(messenger.getMessage());
+		}
+	}
+----
+
+Assume then, for the purposes of this example, that all calls to the `getMessage()`
+method of `Messenger` implementations have to be changed such that the message is
+surrounded by quotation marks. The following listing shows the changes that you
+(the developer) should make to the `Messenger.groovy` source file when the
+execution of the program is paused:
+
+[source,groovy,indent=0,subs="verbatim,quotes",chomp="-packages"]
+----
+	package org.springframework.scripting
+
+	class GroovyMessenger implements Messenger {
+
+		private String message = "Bingo"
+
+		public String getMessage() {
+			// change the implementation to surround the message in quotes
+			return "'" + this.message + "'"
+		}
+
+		public void setMessage(String message) {
+			this.message = message
+		}
+	}
+----
+
+When the program runs, the output before the input pause will be `I Can Do The Frug`.
+After the change to the source file is made and saved and the program resumes execution,
+the result of calling the `getMessage()` method on the dynamic-language-backed
+`Messenger` implementation is `'I Can Do The Frug'` (notice the inclusion of the
+additional quotation marks).
+
+Changes to a script do not trigger a refresh if the changes occur within the window of
+the `refresh-check-delay` value. Changes to the script are not actually picked up until
+a method is called on the dynamic-language-backed bean. It is only when a method is
+called on a dynamic-language-backed bean that it checks to see if its underlying script
+source has changed. Any exceptions that relate to refreshing the script (such as
+encountering a compilation error or finding that the script file has been deleted)
+results in a fatal exception being propagated to the calling code.
+
+The refreshable bean behavior described earlier does not apply to dynamic language
+source files defined with the `<lang:inline-script/>` element notation (see
+xref:languages/dynamic.adoc#dynamic-language-beans-inline[Inline Dynamic Language Source Files]).
+Additionally, it applies only to beans where changes to the underlying source file can
+actually be detected (for example, by code that checks the last modified date of a
+dynamic language source file that exists on the file system).
+
+[[dynamic-language-beans-inline]]
+==== Inline Dynamic Language Source Files
+
+The dynamic language support can also cater to dynamic language source files that are
+embedded directly in Spring bean definitions. More specifically, the
+`<lang:inline-script/>` element lets you define dynamic language source immediately
+inside a Spring configuration file. An example might clarify how the inline script
+feature works:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<lang:groovy id="messenger">
+		<lang:inline-script>
+
+			package org.springframework.scripting.groovy
+
+			import org.springframework.scripting.Messenger
+
+			class GroovyMessenger implements Messenger {
+				String message
+			}
+
+		</lang:inline-script>
+		<lang:property name="message" value="I Can Do The Frug" />
+	</lang:groovy>
+----
+
+If we put to one side the issues surrounding whether it is good practice to define
+dynamic language source inside a Spring configuration file, the `<lang:inline-script/>`
+element can be useful in some scenarios. For instance, we might want to quickly add a
+Spring `Validator` implementation to a Spring MVC `Controller`. This is but a moment's
+work using inline source. (See
+xref:languages/dynamic.adoc#dynamic-language-scenarios-validators[Scripted Validators]
+for such an example.)
+
+[[dynamic-language-beans-ctor-injection]]
+==== Understanding Constructor Injection in the Context of Dynamic-language-backed Beans
+
+There is one very important thing to be aware of with regard to Spring's dynamic
+language support. Namely, you can not (currently) supply constructor arguments
+to dynamic-language-backed beans (and, hence, constructor-injection is not available for
+dynamic-language-backed beans). In the interests of making this special handling of
+constructors and properties 100% clear, the following mixture of code and configuration
+does not work:
+
+.An approach that cannot work
+[source,groovy,indent=0,subs="verbatim,quotes",chomp="-packages"]
+----
+	package org.springframework.scripting.groovy
+
+	import org.springframework.scripting.Messenger
+
+	// from the file 'Messenger.groovy'
+	class GroovyMessenger implements Messenger {
+
+		GroovyMessenger() {}
+
+		// this constructor is not available for Constructor Injection
+		GroovyMessenger(String message) {
+			this.message = message;
+		}
+
+		String message
+
+		String anotherMessage
+	}
+----
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<lang:groovy id="badMessenger"
+		script-source="classpath:Messenger.groovy">
+		<!-- this next constructor argument will not be injected into the GroovyMessenger -->
+		<!-- in fact, this isn't even allowed according to the schema -->
+		<constructor-arg value="This will not work" />
+
+		<!-- only property values are injected into the dynamic-language-backed object -->
+		<lang:property name="anotherMessage" value="Passed straight through to the dynamic-language-backed object" />
+
+	</lang>
+----
+
+In practice this limitation is not as significant as it first appears, since setter
+injection is the injection style favored by the overwhelming majority of developers
+(we leave the discussion as to whether that is a good thing to another day).
+
+[[dynamic-language-beans-groovy]]
+=== Groovy Beans
+
+This section describes how to use beans defined in Groovy in Spring.
+
+The Groovy homepage includes the following description:
+
+"`Groovy is an agile dynamic language for the Java 2 Platform that has many of the
+features that people like so much in languages like Python, Ruby and Smalltalk, making
+them available to Java developers using a Java-like syntax.`"
+
+If you have read this chapter straight from the top, you have already
+xref:languages/dynamic.adoc#dynamic-language-a-first-example[seen an example] of a Groovy-dynamic-language-backed
+bean. Now consider another example (again using an example from the Spring test suite):
+
+[source,java,indent=0,subs="verbatim,quotes",chomp="-packages"]
+----
+	package org.springframework.scripting;
+
+	public interface Calculator {
+
+		int add(int x, int y);
+	}
+----
+
+The following example implements the `Calculator` interface in Groovy:
+
+[source,groovy,indent=0,subs="verbatim,quotes",chomp="-packages"]
+----
+	package org.springframework.scripting.groovy
+
+	// from the file 'calculator.groovy'
+	class GroovyCalculator implements Calculator {
+
+		int add(int x, int y) {
+			x + y
+		}
+	}
+----
+
+The following bean definition uses the calculator defined in Groovy:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<!-- from the file 'beans.xml' -->
+	<beans>
+		<lang:groovy id="calculator" script-source="classpath:calculator.groovy"/>
+	</beans>
+----
+
+Finally, the following small application exercises the preceding configuration:
+
+[source,java,indent=0,subs="verbatim,quotes",chomp="-packages"]
+----
+	package org.springframework.scripting;
+
+	import org.springframework.context.ApplicationContext;
+	import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+	public class Main {
+
+		public static void main(String[] args) {
+			ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
+			Calculator calc = ctx.getBean("calculator", Calculator.class);
+			System.out.println(calc.add(2, 8));
+		}
+	}
+----
+
+The resulting output from running the above program is (unsurprisingly) `10`.
+(For more interesting examples, see the dynamic language showcase project for a more
+complex example or see the examples xref:languages/dynamic.adoc#dynamic-language-scenarios[Scenarios] later in this chapter).
+
+You must not define more than one class per Groovy source file. While this is perfectly
+legal in Groovy, it is (arguably) a bad practice. In the interests of a consistent
+approach, you should (in the opinion of the Spring team) respect the standard Java
+conventions of one (public) class per source file.
+
+[[dynamic-language-beans-groovy-customizer]]
+==== Customizing Groovy Objects by Using a Callback
+
+The `GroovyObjectCustomizer` interface is a callback that lets you hook additional
+creation logic into the process of creating a Groovy-backed bean. For example,
+implementations of this interface could invoke any required initialization methods,
+set some default property values, or specify a custom `MetaClass`. The following listing
+shows the `GroovyObjectCustomizer` interface definition:
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	public interface GroovyObjectCustomizer {
+
+		void customize(GroovyObject goo);
+	}
+----
+
+The Spring Framework instantiates an instance of your Groovy-backed bean and then
+passes the created `GroovyObject` to the specified `GroovyObjectCustomizer` (if one
+has been defined). You can do whatever you like with the supplied `GroovyObject`
+reference. We expect that most people want to set a custom `MetaClass` with this
+callback, and the following example shows how to do so:
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	public final class SimpleMethodTracingCustomizer implements GroovyObjectCustomizer {
+
+		public void customize(GroovyObject goo) {
+			DelegatingMetaClass metaClass = new DelegatingMetaClass(goo.getMetaClass()) {
+
+				public Object invokeMethod(Object object, String methodName, Object[] arguments) {
+					System.out.println("Invoking '" + methodName + "'.");
+					return super.invokeMethod(object, methodName, arguments);
+				}
+			};
+			metaClass.initialize();
+			goo.setMetaClass(metaClass);
+		}
+
+	}
+----
+
+A full discussion of meta-programming in Groovy is beyond the scope of the Spring
+reference manual. See the relevant section of the Groovy reference manual or do a
+search online. Plenty of articles address this topic. Actually, making use of a
+`GroovyObjectCustomizer` is easy if you use the Spring namespace support, as the
+following example shows:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<!-- define the GroovyObjectCustomizer just like any other bean -->
+	<bean id="tracingCustomizer" class="example.SimpleMethodTracingCustomizer"/>
+
+		<!-- ... and plug it into the desired Groovy bean via the 'customizer-ref' attribute -->
+		<lang:groovy id="calculator"
+			script-source="classpath:org/springframework/scripting/groovy/Calculator.groovy"
+			customizer-ref="tracingCustomizer"/>
+----
+
+If you do not use the Spring namespace support, you can still use the
+`GroovyObjectCustomizer` functionality, as the following example shows:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<bean id="calculator" class="org.springframework.scripting.groovy.GroovyScriptFactory">
+		<constructor-arg value="classpath:org/springframework/scripting/groovy/Calculator.groovy"/>
+		<!-- define the GroovyObjectCustomizer (as an inner bean) -->
+		<constructor-arg>
+			<bean id="tracingCustomizer" class="example.SimpleMethodTracingCustomizer"/>
+		</constructor-arg>
+	</bean>
+
+	<bean class="org.springframework.scripting.support.ScriptFactoryPostProcessor"/>
+----
+
+NOTE: You may also specify a Groovy `CompilationCustomizer` (such as an `ImportCustomizer`)
+or even a full Groovy `CompilerConfiguration` object in the same place as Spring's
+`GroovyObjectCustomizer`. Furthermore, you may set a common `GroovyClassLoader` with custom
+configuration for your beans at the `ConfigurableApplicationContext.setClassLoader` level;
+this also leads to shared `GroovyClassLoader` usage and is therefore recommendable in case of
+a large number of scripted beans (avoiding an isolated `GroovyClassLoader` instance per bean).
+
+[[dynamic-language-beans-bsh]]
+=== BeanShell Beans
+
+This section describes how to use BeanShell beans in Spring.
+
+The https://beanshell.github.io/intro.html[BeanShell homepage] includes the following
+description:
+
+----
+BeanShell is a small, free, embeddable Java source interpreter with dynamic language
+features, written in Java. BeanShell dynamically runs standard Java syntax and
+extends it with common scripting conveniences such as loose types, commands, and method
+closures like those in Perl and JavaScript.
+----
+
+In contrast to Groovy, BeanShell-backed bean definitions require some (small) additional
+configuration. The implementation of the BeanShell dynamic language support in Spring is
+interesting, because Spring creates a JDK dynamic proxy that implements all of the
+interfaces that are specified in the `script-interfaces` attribute value of the
+`<lang:bsh>` element (this is why you must supply at least one interface in the value
+of the attribute, and, consequently, program to interfaces when you use BeanShell-backed
+beans). This means that every method call on a BeanShell-backed object goes through the
+JDK dynamic proxy invocation mechanism.
+
+Now we can show a fully working example of using a BeanShell-based bean that implements
+the `Messenger` interface that was defined earlier in this chapter. We again show the
+definition of the `Messenger` interface:
+
+[source,java,indent=0,subs="verbatim,quotes",chomp="-packages"]
+----
+	package org.springframework.scripting;
+
+	public interface Messenger {
+
+		String getMessage();
+	}
+----
+
+The following example shows the BeanShell "`implementation`" (we use the term loosely here)
+of the `Messenger` interface:
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	String message;
+
+	String getMessage() {
+		return message;
+	}
+
+	void setMessage(String aMessage) {
+		message = aMessage;
+	}
+----
+
+The following example shows the Spring XML that defines an "`instance`" of the above
+"`class`" (again, we use these terms very loosely here):
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<lang:bsh id="messageService" script-source="classpath:BshMessenger.bsh"
+		script-interfaces="org.springframework.scripting.Messenger">
+
+		<lang:property name="message" value="Hello World!" />
+	</lang:bsh>
+----
+
+See xref:languages/dynamic.adoc#dynamic-language-scenarios[Scenarios] for some scenarios
+where you might want to use BeanShell-based beans.
+
+
+[[dynamic-language-scenarios]]
+== Scenarios
+
+The possible scenarios where defining Spring managed beans in a scripting language would
+be beneficial are many and varied. This section describes two possible use cases for the
+dynamic language support in Spring.
+
+[[dynamic-language-scenarios-controllers]]
+=== Scripted Spring MVC Controllers
+
+One group of classes that can benefit from using dynamic-language-backed beans is that
+of Spring MVC controllers. In pure Spring MVC applications, the navigational flow
+through a web application is, to a large extent, determined by code encapsulated within
+your Spring MVC controllers. As the navigational flow and other presentation layer logic
+of a web application needs to be updated to respond to support issues or changing
+business requirements, it may well be easier to effect any such required changes by
+editing one or more dynamic language source files and seeing those changes being
+immediately reflected in the state of a running application.
+
+Remember that, in the lightweight architectural model espoused by projects such as
+Spring, you typically aim to have a really thin presentation layer, with all
+the meaty business logic of an application being contained in the domain and service
+layer classes. Developing Spring MVC controllers as dynamic-language-backed beans lets
+you change presentation layer logic by editing and saving text files. Any
+changes to such dynamic language source files is (depending on the configuration)
+automatically reflected in the beans that are backed by dynamic language source files.
+
+NOTE: To effect this automatic "`pickup`" of any changes to dynamic-language-backed
+beans, you have to enable the "`refreshable beans`" functionality. See
+xref:languages/dynamic.adoc#dynamic-language-refreshable-beans[Refreshable Beans] for a full treatment of this feature.
+
+The following example shows an `org.springframework.web.servlet.mvc.Controller` implemented
+by using the Groovy dynamic language:
+
+[source,groovy,indent=0,subs="verbatim,quotes",chomp="-packages"]
+----
+	package org.springframework.showcase.fortune.web
+
+	import org.springframework.showcase.fortune.service.FortuneService
+	import org.springframework.showcase.fortune.domain.Fortune
+	import org.springframework.web.servlet.ModelAndView
+	import org.springframework.web.servlet.mvc.Controller
+
+	import jakarta.servlet.http.HttpServletRequest
+	import jakarta.servlet.http.HttpServletResponse
+
+	// from the file '/WEB-INF/groovy/FortuneController.groovy'
+	class FortuneController implements Controller {
+
+		@Property FortuneService fortuneService
+
+		ModelAndView handleRequest(HttpServletRequest request,
+				HttpServletResponse httpServletResponse) {
+			return new ModelAndView("tell", "fortune", this.fortuneService.tellFortune())
+		}
+	}
+----
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<lang:groovy id="fortune"
+			refresh-check-delay="3000"
+			script-source="/WEB-INF/groovy/FortuneController.groovy">
+		<lang:property name="fortuneService" ref="fortuneService"/>
+	</lang:groovy>
+----
+
+[[dynamic-language-scenarios-validators]]
+=== Scripted Validators
+
+Another area of application development with Spring that may benefit from the
+flexibility afforded by dynamic-language-backed beans is that of validation. It can
+be easier to express complex validation logic by using a loosely typed dynamic language
+(that may also have support for inline regular expressions) as opposed to regular Java.
+
+Again, developing validators as dynamic-language-backed beans lets you change
+validation logic by editing and saving a simple text file. Any such changes is
+(depending on the configuration) automatically reflected in the execution of a
+running application and would not require the restart of an application.
+
+NOTE: To effect the automatic "`pickup`" of any changes to dynamic-language-backed
+beans, you have to enable the 'refreshable beans' feature. See
+xref:languages/dynamic.adoc#dynamic-language-refreshable-beans[Refreshable Beans]
+for a full and detailed treatment of this feature.
+
+The following example shows a Spring `org.springframework.validation.Validator`
+implemented by using the Groovy dynamic language (see
+xref:core/validation/validator.adoc[Validation using Spring’s Validator interface]
+for a discussion of the `Validator` interface):
+
+[source,groovy,indent=0,subs="verbatim,quotes"]
+----
+	import org.springframework.validation.Validator
+	import org.springframework.validation.Errors
+	import org.springframework.beans.TestBean
+
+	class TestBeanValidator implements Validator {
+
+		boolean supports(Class clazz) {
+			return TestBean.class.isAssignableFrom(clazz)
+		}
+
+		void validate(Object bean, Errors errors) {
+			if(bean.name?.trim()?.size() > 0) {
+				return
+			}
+			errors.reject("whitespace", "Cannot be composed wholly of whitespace.")
+		}
+	}
+----
+
+
+[[dynamic-language-final-notes]]
+== Additional Details
+
+This last section contains some additional details related to the dynamic language support.
+
+[[dynamic-language-final-notes-aop]]
+=== AOP -- Advising Scripted Beans
+
+You can use the Spring AOP framework to advise scripted beans. The Spring AOP
+framework actually is unaware that a bean that is being advised might be a scripted
+bean, so all of the AOP use cases and functionality that you use (or aim to use)
+work with scripted beans. When you advise scripted beans, you cannot use class-based
+proxies. You must use xref:core/aop/proxying.adoc[interface-based proxies].
+
+You are not limited to advising scripted beans. You can also write aspects themselves
+in a supported dynamic language and use such beans to advise other Spring beans.
+This really would be an advanced use of the dynamic language support though.
+
+[[dynamic-language-final-notes-scopes]]
+=== Scoping
+
+In case it is not immediately obvious, scripted beans can be scoped in the same way as
+any other bean. The `scope` attribute on the various `<lang:language/>` elements lets
+you control the scope of the underlying scripted bean, as it does with a regular
+bean. (The default scope is xref:core/beans/factory-scopes.adoc#beans-factory-scopes-singleton[singleton],
+as it is with "`regular`" beans.)
+
+The following example uses the `scope` attribute to define a Groovy bean scoped as
+a xref:core/beans/factory-scopes.adoc#beans-factory-scopes-prototype[prototype]:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<?xml version="1.0" encoding="UTF-8"?>
+	<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:lang="http://www.springframework.org/schema/lang"
+		xsi:schemaLocation="
+			http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
+			http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">
+
+		<lang:groovy id="messenger" script-source="classpath:Messenger.groovy" scope="prototype">
+			<lang:property name="message" value="I Can Do The RoboCop" />
+		</lang:groovy>
+
+		<bean id="bookingService" class="x.y.DefaultBookingService">
+			<property name="messenger" ref="messenger" />
+		</bean>
+
+	</beans>
+----
+
+See xref:core/beans/factory-scopes.adoc[Bean Scopes] in
+xref:web/webmvc-view/mvc-xslt.adoc#mvc-view-xslt-beandefs[The IoC Container]
+for a full discussion of the scoping support in the Spring Framework.
+
+[[xsd-schemas-lang]]
+=== The `lang` XML schema
+
+The `lang` elements in Spring XML configuration deal with exposing objects that have been
+written in a dynamic language (such as Groovy or BeanShell) as beans in the Spring container.
+
+These elements (and the dynamic language support) are comprehensively covered in
+xref:languages/dynamic.adoc[Dynamic Language Support]. See that section
+for full details on this support and the `lang` elements.
+
+To use the elements in the `lang` schema, you need to have the following preamble at the
+top of your Spring XML configuration file. The text in the following snippet references
+the correct schema so that the tags in the `lang` namespace are available to you:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<?xml version="1.0" encoding="UTF-8"?>
+	<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:lang="http://www.springframework.org/schema/lang"
+		xsi:schemaLocation="
+			http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
+			http://www.springframework.org/schema/lang https://www.springframework.org/schema/lang/spring-lang.xsd">
+
+		<!-- bean definitions here -->
+
+	</beans>
+----
+
+
+[[dynamic-language-resources]]
+== Further Resources
+
+The following links go to further resources about the various dynamic languages referenced
+in this chapter:
+
+* The https://www.groovy-lang.org/[Groovy] homepage
+* The https://beanshell.github.io/intro.html[BeanShell] homepage
+* The https://www.jruby.org[JRuby] homepage

framework-docs/modules/ROOT/pages/languages/groovy.adoc

@@ -6,37 +6,9 @@ Groovy is a powerful, optionally typed, and dynamic language, with static-typing
 compilation capabilities. It offers a concise syntax and integrates smoothly with any
 existing Java application.
 
-[[beans-factory-groovy]]
-== The Groovy Bean Definition DSL
-
 The Spring Framework provides a dedicated `ApplicationContext` that supports a Groovy-based
-Bean Definition DSL, as known from the Grails framework.
-
-Typically, such configuration live in a ".groovy" file with the structure shown in the
-following example:
-
-[source,groovy,indent=0,subs="verbatim,quotes"]
-----
-	beans {
-		dataSource(BasicDataSource) {
-			driverClassName = "org.hsqldb.jdbcDriver"
-			url = "jdbc:hsqldb:mem:grailsDB"
-			username = "sa"
-			password = ""
-			settings = [mynew:"setting"]
-		}
-		sessionFactory(SessionFactory) {
-			dataSource = dataSource
-		}
-		myService(MyService) {
-			nestedBean = { AnotherBean bean ->
-				dataSource = dataSource
-			}
-		}
-	}
-----
-
-This configuration style is largely equivalent to XML bean definitions and even
-supports Spring's XML configuration namespaces. It also allows for importing XML
-bean definition files through an `importBeans` directive.
+Bean Definition DSL. For more details, see
+xref:core/beans/basics.adoc#beans-factory-groovy[The Groovy Bean Definition DSL].
 
+Further support for Groovy, including beans written in Groovy, refreshable script beans,
+and more is available in xref:languages/dynamic.adoc[Dynamic Language Support].

framework-docs/modules/ROOT/pages/languages/kotlin/bean-definition-dsl.adoc

@@ -1,4 +1,4 @@
-[[kotlin-bean-registration-dsl]]
-= Bean Registration DSL
+[[kotlin-bean-definition-dsl]]
+= Bean Definition DSL
 
 See xref:core/beans/java/programmatic-bean-registration.adoc[Programmatic Bean Registration].

framework-docs/modules/ROOT/pages/languages/kotlin/classes-interfaces.adoc

@@ -13,4 +13,4 @@ running the Kotlin compiler with its `-java-parameters` flag for standard Java p
 
 You can declare configuration classes as
 {kotlin-docs}/nested-classes.html[top level or nested but not inner],
-since the latter requires a reference to the outer class.
+since the later requires a reference to the outer class.

framework-docs/modules/ROOT/pages/languages/kotlin/coroutines.adoc

@@ -264,11 +264,9 @@ The {spring-framework-api-kdoc}/spring-core/org.springframework.core/-propagatio
 {micrometer-context-propagation-docs}/[Micrometer Context Propagation library] works with Kotlin Coroutines.
 
 It requires the `io.micrometer:context-propagation` dependency and optionally the
-`org.jetbrains.kotlinx:kotlinx-coroutines-reactor` one. Automatic context propagation via
-`CoroutinesUtils#invokeSuspendingFunction` (used by Spring to adapt Coroutines to Reactor `Flux` or `Mono`) can be
-enabled by invoking `Hooks.enableAutomaticContextPropagation()`.
+`org.jetbrains.kotlinx:kotlinx-coroutines-reactor` one.
 
-Applications can also use `PropagationContextElement` explicitly to augment the `CoroutineContext`
+Applications can then use the `PropagationContextElement` to augment the `CoroutineContext`
 with the context propagation mechanism:
 
 include-code::./ContextPropagationSample[tag=context,indent=0]

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

@@ -319,17 +319,9 @@ progresses.
 == Testing
 
 This section addresses testing with the combination of Kotlin and Spring Framework.
-The recommended testing framework is https://junit.org/[JUnit] along with
+The recommended testing framework is https://junit.org/junit5/[JUnit] along with
 https://mockk.io/[Mockk] for mocking.
 
-[TIP]
-====
-Kotlin lets you specify meaningful test function names between backticks (```).
-
-For a concrete example, see the `+++`Find all users on HTML page`()+++` test function later
-in this section.
-====
-
 NOTE: If you are using Spring Boot, see
 {spring-boot-docs-ref}/features/kotlin.html#features.kotlin.testing[this related documentation].
 
@@ -360,6 +352,7 @@ file with a `spring.test.constructor.autowire.mode = all` property.
 [[per_class-lifecycle]]
 === `PER_CLASS` Lifecycle
 
+Kotlin lets you specify meaningful test function names between backticks (```).
 With JUnit Jupiter, 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.

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

@@ -237,8 +237,8 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	RSocketStrategies strategies = RSocketStrategies.builder()
-		.encoders(encoders -> encoders.add(new JacksonCborEncoder()))
-		.decoders(decoders -> decoders.add(new JacksonCborDecoder()))
+		.encoders(encoders -> encoders.add(new Jackson2CborEncoder()))
+		.decoders(decoders -> decoders.add(new Jackson2CborDecoder()))
 		.build();
 
 	RSocketRequester requester = RSocketRequester.builder()
@@ -251,8 +251,8 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	val strategies = RSocketStrategies.builder()
-			.encoders { it.add(JacksonCborEncoder()) }
-			.decoders { it.add(JacksonCborDecoder()) }
+			.encoders { it.add(Jackson2CborEncoder()) }
+			.decoders { it.add(Jackson2CborDecoder()) }
 			.build()
 
 	val requester = RSocketRequester.builder()
@@ -681,8 +681,8 @@ Java::
 		@Bean
 		public RSocketStrategies rsocketStrategies() {
 			return RSocketStrategies.builder()
-				.encoders(encoders -> encoders.add(new JacksonCborEncoder()))
-				.decoders(decoders -> decoders.add(new JacksonCborDecoder()))
+				.encoders(encoders -> encoders.add(new Jackson2CborEncoder()))
+				.decoders(decoders -> decoders.add(new Jackson2CborDecoder()))
 				.routeMatcher(new PathPatternRouteMatcher())
 				.build();
 		}
@@ -703,8 +703,8 @@ Kotlin::
 
 		@Bean
 		fun rsocketStrategies() = RSocketStrategies.builder()
-				.encoders { it.add(JacksonCborEncoder()) }
-				.decoders { it.add(JacksonCborDecoder()) }
+				.encoders { it.add(Jackson2CborEncoder()) }
+				.decoders { it.add(Jackson2CborDecoder()) }
 				.routeMatcher(PathPatternRouteMatcher())
 				.build()
 	}

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

@@ -187,7 +187,7 @@ default mode may be set via the
 xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
 
 The default mode may also be configured as a
-https://docs.junit.org/current/user-guide/#running-tests-config-params[JUnit Platform configuration parameter].
+https://junit.org/junit5/docs/current/user-guide/#running-tests-config-params[JUnit Platform configuration parameter].
 
 If the `spring.test.constructor.autowire.mode` property is not set, test class
 constructors will not be automatically autowired.

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

@@ -2,12 +2,11 @@
 = Meta-Annotation Support for Testing
 
 You can use most test-related annotations as
-xref:core/beans/classpath-scanning.adoc#beans-meta-annotations[meta-annotations] to
-create custom composed annotations and reduce configuration duplication across a test
-suite.
+xref:core/beans/classpath-scanning.adoc#beans-meta-annotations[meta-annotations] to create custom composed
+annotations and reduce configuration duplication across a test suite.
 
-For example, you can use each of the following as a meta-annotation in conjunction with
-the xref:testing/testcontext-framework.adoc[TestContext framework].
+You can use each of the following as a meta-annotation in conjunction with the
+xref:testing/testcontext-framework.adoc[TestContext framework].
 
 * `@BootstrapWith`
 * `@ContextConfiguration`
@@ -38,7 +37,111 @@ the xref:testing/testcontext-framework.adoc[TestContext framework].
 * `@EnabledIf` _(only supported on JUnit Jupiter)_
 * `@DisabledIf` _(only supported on JUnit Jupiter)_
 
-Consider the following test classes that use the `SpringExtension` with JUnit Jupiter:
+Consider the following example:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@RunWith(SpringRunner.class)
+	@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
+	@ActiveProfiles("dev")
+	@Transactional
+	public class OrderRepositoryTests { }
+
+	@RunWith(SpringRunner.class)
+	@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
+	@ActiveProfiles("dev")
+	@Transactional
+	public class UserRepositoryTests { }
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@RunWith(SpringRunner::class)
+	@ContextConfiguration("/app-config.xml", "/test-data-access-config.xml")
+	@ActiveProfiles("dev")
+	@Transactional
+	class OrderRepositoryTests { }
+
+	@RunWith(SpringRunner::class)
+	@ContextConfiguration("/app-config.xml", "/test-data-access-config.xml")
+	@ActiveProfiles("dev")
+	@Transactional
+	class UserRepositoryTests { }
+----
+======
+
+If we discover that we are repeating the preceding configuration across our JUnit 4-based
+test suite, we can reduce the duplication by introducing a custom composed annotation
+that centralizes the common test configuration for Spring, as follows:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@Target(ElementType.TYPE)
+	@Retention(RetentionPolicy.RUNTIME)
+	@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
+	@ActiveProfiles("dev")
+	@Transactional
+	public @interface TransactionalDevTestConfig { }
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@Target(AnnotationTarget.TYPE)
+	@Retention(AnnotationRetention.RUNTIME)
+	@ContextConfiguration("/app-config.xml", "/test-data-access-config.xml")
+	@ActiveProfiles("dev")
+	@Transactional
+	annotation class TransactionalDevTestConfig { }
+----
+======
+
+Then we can use our custom `@TransactionalDevTestConfig` annotation to simplify the
+configuration of individual JUnit 4 based test classes, as follows:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@RunWith(SpringRunner.class)
+	@TransactionalDevTestConfig
+	public class OrderRepositoryTests { }
+
+	@RunWith(SpringRunner.class)
+	@TransactionalDevTestConfig
+	public class UserRepositoryTests { }
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@RunWith(SpringRunner::class)
+	@TransactionalDevTestConfig
+	class OrderRepositoryTests
+
+	@RunWith(SpringRunner::class)
+	@TransactionalDevTestConfig
+	class UserRepositoryTests
+----
+======
+
+If we write tests that use JUnit Jupiter, we can reduce code duplication even further,
+since annotations in JUnit Jupiter can also be used as meta-annotations. Consider the
+following example:
 
 [tabs]
 ======
@@ -47,13 +150,13 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	@ExtendWith(SpringExtension.class)
-	@ContextConfiguration(classes = {AppConfig.class, TestDataAccessConfig.class})
+	@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
 	@ActiveProfiles("dev")
 	@Transactional
 	class OrderRepositoryTests { }
 
 	@ExtendWith(SpringExtension.class)
-	@ContextConfiguration(classes = {AppConfig.class, TestDataAccessConfig.class})
+	@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
 	@ActiveProfiles("dev")
 	@Transactional
 	class UserRepositoryTests { }
@@ -64,22 +167,23 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@ExtendWith(SpringExtension::class)
-	@ContextConfiguration(classes = [AppConfig::class, TestDataAccessConfig::class])
+	@ContextConfiguration("/app-config.xml", "/test-data-access-config.xml")
 	@ActiveProfiles("dev")
 	@Transactional
 	class OrderRepositoryTests { }
 
 	@ExtendWith(SpringExtension::class)
-	@ContextConfiguration(classes = [AppConfig::class, TestDataAccessConfig::class])
+	@ContextConfiguration("/app-config.xml", "/test-data-access-config.xml")
 	@ActiveProfiles("dev")
 	@Transactional
 	class UserRepositoryTests { }
 ----
 ======
 
-If we discover that we are repeating the preceding configuration across our test suite,
-we can reduce the duplication by introducing a custom composed annotation that
-centralizes the common test configuration for Spring and JUnit Jupiter, as follows:
+If we discover that we are repeating the preceding configuration across our JUnit
+Jupiter-based test suite, we can reduce the duplication by introducing a custom composed
+annotation that centralizes the common test configuration for Spring and JUnit Jupiter,
+as follows:
 
 [tabs]
 ======
@@ -90,7 +194,7 @@ Java::
 	@Target(ElementType.TYPE)
 	@Retention(RetentionPolicy.RUNTIME)
 	@ExtendWith(SpringExtension.class)
-	@ContextConfiguration(classes = {AppConfig.class, TestDataAccessConfig.class})
+	@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
 	@ActiveProfiles("dev")
 	@Transactional
 	public @interface TransactionalDevTestConfig { }
@@ -103,7 +207,7 @@ Kotlin::
 	@Target(AnnotationTarget.TYPE)
 	@Retention(AnnotationRetention.RUNTIME)
 	@ExtendWith(SpringExtension::class)
-	@ContextConfiguration(classes = [AppConfig::class, TestDataAccessConfig::class])
+	@ContextConfiguration("/app-config.xml", "/test-data-access-config.xml")
 	@ActiveProfiles("dev")
 	@Transactional
 	annotation class TransactionalDevTestConfig { }

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

@@ -102,10 +102,6 @@ will be replaced with a singleton mock of the type of object created by the `Fac
 
 Similarly, when using `@MockitoSpyBean` to create a spy for a `FactoryBean`, a spy will
 be created for the object created by the `FactoryBean`, not for the `FactoryBean` itself.
-
-Furthermore, `@MockitoSpyBean` cannot be used to spy on a scoped proxy — for example, a
-bean annotated with `@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)`. Any attempt to do
-so will fail with an exception.
 ====
 
 [NOTE]

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

@@ -5,25 +5,24 @@ It is important to be able to perform some integration testing without requiring
 deployment to your application server or connecting to other enterprise infrastructure.
 Doing so lets you test things such as:
 
-* The correct wiring of your Spring components.
-* Data access using JDBC or an ORM tool.
-  ** This can include such things as the correctness of SQL statements, Hibernate queries,
-     JPA entity mappings, and so forth.
+* The correct wiring of your Spring IoC container contexts.
+* Data access using JDBC or an ORM tool. This can include such things as the correctness
+  of SQL statements, Hibernate queries, JPA entity mappings, and so forth.
 
 The Spring Framework provides first-class support for integration testing in the
-`spring-test` module. The name of the actual JAR file might include the release version,
-depending on where you get it from (see the
-{spring-framework-wiki}/Spring-Framework-Artifacts[Spring Framework Artifacts] wiki page
-for details). This library includes the `org.springframework.test` package, which
+`spring-test` module. The name of the actual JAR file might include the release version
+and might also be in the long `org.springframework.test` form, depending on where you get
+it from (see the xref:core/beans/dependencies.adoc[section on Dependency Management]
+for an explanation). This library includes the `org.springframework.test` package, which
 contains valuable classes for integration testing with a Spring container. This testing
 does not rely on an application server or other deployment environment. Such tests are
 slower to run than unit tests but much faster than the equivalent Selenium tests or
 remote tests that rely on deployment to an application server.
 
 Unit and integration testing support is provided in the form of the annotation-driven
-xref:testing/testcontext-framework.adoc[Spring TestContext Framework]. The TestContext
-framework is agnostic of the actual testing framework in use, which allows
-instrumentation of tests in various environments, including JUnit, TestNG, and others.
+xref:testing/testcontext-framework.adoc[Spring TestContext Framework]. The TestContext framework is
+agnostic of the actual testing framework in use, which allows instrumentation of tests
+in various environments, including JUnit, TestNG, and others.
 
 The following section provides an overview of the high-level goals of Spring's
 integration support, and the rest of this chapter then focuses on dedicated topics:

framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/expectations.adoc

@@ -184,10 +184,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	standaloneSetup(SimpleController())
-		.alwaysExpect<StandaloneMockMvcBuilder>(status().isOk())
-		.alwaysExpect<StandaloneMockMvcBuilder>(content().contentType("application/json;charset=UTF-8"))
-		.build()
+	// Not possible in Kotlin until {kotlin-issues}/KT-22208 is fixed
 ----
 ======
 

framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/filters.adoc

@@ -18,7 +18,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	mockMvc = standaloneSetup(PersonController()).addFilters<StandaloneMockMvcBuilder>(CharacterEncodingFilter()).build()
+	// Not possible in Kotlin until {kotlin-issues}/KT-22208 is fixed
 ----
 ======
 

framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/requests.adoc

@@ -159,18 +159,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	class MyWebTests {
-
-		lateinit var mockMvc: MockMvc
-
-		@BeforeEach
-		fun setup() {
-			mockMvc = standaloneSetup(AccountController())
-				.defaultRequest<StandaloneMockMvcBuilder>(get("/")
-				.contextPath("/app").servletPath("/main")
-				.accept(MediaType.APPLICATION_JSON)).build()
-		}
-	}
+	// Not possible in Kotlin until {kotlin-issues}/KT-22208 is fixed
 ----
 ======
 

framework-docs/modules/ROOT/pages/testing/mockmvc/hamcrest/setup-steps.adoc

@@ -25,13 +25,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	// static import of MockMvcBuilders.standaloneSetup
-
-	val mockMvc = standaloneSetup(MusicController())
-		.defaultRequest<StandaloneMockMvcBuilder>(get("/").accept(MediaType.APPLICATION_JSON))
-		.alwaysExpect<StandaloneMockMvcBuilder>(status().isOk())
-		.alwaysExpect<StandaloneMockMvcBuilder>(content().contentType("application/json;charset=UTF-8"))
-		.build()
+	// Not possible in Kotlin until {kotlin-issues}/KT-22208 is fixed
 ----
 ======
 
@@ -59,13 +53,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	// static import of SharedHttpSessionConfigurer.sharedHttpSession
-
-	val mockMvc = MockMvcBuilders.standaloneSetup(TestController())
-			.apply<StandaloneMockMvcBuilder>(sharedHttpSession())
-			.build()
-
-	// Use mockMvc to perform requests...
+	// Not possible in Kotlin until {kotlin-issues}/KT-22208 is fixed
 ----
 ======
 

framework-docs/modules/ROOT/pages/testing/mockmvc/htmlunit/geb.adoc

@@ -8,9 +8,9 @@ use https://www.gebish.org/[Geb] to make our tests even Groovy-er.
 == Why Geb and MockMvc?
 
 Geb is backed by WebDriver, so it offers many of the
-xref:testing/mockmvc/htmlunit/webdriver.adoc#mockmvc-server-htmlunit-webdriver-why[same benefits]
-that we get from WebDriver. However, Geb makes things even easier by taking care of some
-of the boilerplate code for us.
+xref:testing/mockmvc/htmlunit/webdriver.adoc#spring-mvc-test-server-htmlunit-webdriver-why[same benefits] that we get from
+WebDriver. However, Geb makes things even easier by taking care of some of the
+boilerplate code for us.
 
 [[mockmvc-server-htmlunit-geb-setup]]
 == MockMvc and Geb Setup
@@ -28,8 +28,7 @@ def setup() {
 ----
 
 NOTE: This is a simple example of using `MockMvcHtmlUnitDriverBuilder`. For more advanced
-usage, see
-xref:testing/mockmvc/htmlunit/webdriver.adoc#mockmvc-server-htmlunit-webdriver-advanced-builder[Advanced `MockMvcHtmlUnitDriverBuilder`].
+usage, see xref:testing/mockmvc/htmlunit/webdriver.adoc#spring-mvc-test-server-htmlunit-webdriver-advanced-builder[Advanced `MockMvcHtmlUnitDriverBuilder`].
 
 This ensures that any URL referencing `localhost` as the server is directed to our
 `MockMvc` instance without the need for a real HTTP connection. Any other URL is
@@ -63,10 +62,10 @@ forwarded to the current page object. This removes a lot of the boilerplate code
 needed when using WebDriver directly.
 
 As with direct WebDriver usage, this improves on the design of our
-xref:testing/mockmvc/htmlunit/mah.adoc#mockmvc-server-htmlunit-mah-usage[HtmlUnit test]
-by using the Page Object Pattern. As mentioned previously, we can use the Page Object
-Pattern with HtmlUnit and WebDriver, but it is even easier with Geb. Consider our new
-Groovy-based `CreateMessagePage` implementation:
+xref:testing/mockmvc/htmlunit/mah.adoc#spring-mvc-test-server-htmlunit-mah-usage[HtmlUnit test] by using the Page Object
+Pattern. As mentioned previously, we can use the Page Object Pattern with HtmlUnit and
+WebDriver, but it is even easier with Geb. Consider our new Groovy-based
+`CreateMessagePage` implementation:
 
 [source,groovy]
 ----

framework-docs/modules/ROOT/pages/testing/mockmvc/htmlunit/mah.adoc

@@ -7,7 +7,8 @@ to use the raw HtmlUnit libraries.
 [[mockmvc-server-htmlunit-mah-setup]]
 == MockMvc and HtmlUnit Setup
 
-First, make sure that you have included a test dependency on `org.htmlunit:htmlunit`.
+First, make sure that you have included a test dependency on
+`org.htmlunit:htmlunit`.
 
 We can easily create an HtmlUnit `WebClient` that integrates with MockMvc by using the
 `MockMvcWebClientBuilder`, as follows:
@@ -44,7 +45,7 @@ Kotlin::
 ======
 
 NOTE: This is a simple example of using `MockMvcWebClientBuilder`. For advanced usage,
-see <<mockmvc-server-htmlunit-mah-advanced-builder>>.
+see xref:testing/mockmvc/htmlunit/mah.adoc#spring-mvc-test-server-htmlunit-mah-advanced-builder[Advanced `MockMvcWebClientBuilder`].
 
 This ensures that any URL that references `localhost` as the server is directed to our
 `MockMvc` instance without the need for a real HTTP connection. Any other URL is
@@ -76,7 +77,7 @@ Kotlin::
 ======
 
 NOTE: The default context path is `""`. Alternatively, we can specify the context path,
-as described in <<mockmvc-server-htmlunit-mah-advanced-builder>>.
+as described in xref:testing/mockmvc/htmlunit/mah.adoc#spring-mvc-test-server-htmlunit-mah-advanced-builder[Advanced `MockMvcWebClientBuilder`].
 
 Once we have a reference to the `HtmlPage`, we can then fill out the form and submit it
 to create a message, as the following example shows:
@@ -143,10 +144,10 @@ Kotlin::
 ======
 
 The preceding code improves on our
-xref:testing/mockmvc/htmlunit/why.adoc#mockmvc-server-htmlunit-why[MockMvc test] in a
-number of ways. First, we no longer have to explicitly verify our form and then create a
-request that looks like the form. Instead, we request the form, fill it out, and submit
-it, thereby significantly reducing the overhead.
+xref:testing/mockmvc/htmlunit/why.adoc#spring-mvc-test-server-htmlunit-mock-mvc-test[MockMvc test] in a number of ways.
+First, we no longer have to explicitly verify our form and then create a request that
+looks like the form. Instead, we request the form, fill it out, and submit it, thereby
+significantly reducing the overhead.
 
 Another important factor is that https://htmlunit.sourceforge.io/javascript.html[HtmlUnit
 uses the Mozilla Rhino engine] to evaluate JavaScript. This means that we can also test
@@ -266,19 +267,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	val mockMvc = MockMvcBuilders
-			.webAppContextSetup(context)
-			.apply<DefaultMockMvcBuilder>(springSecurity())
-			.build()
-
-	webClient = MockMvcWebClientBuilder
-			.mockMvcSetup(mockMvc)
-			// for illustration only - defaults to ""
-			.contextPath("")
-			// By default MockMvc is used for localhost only;
-			// the following will use MockMvc for example.com and example.org as well
-			.useMockMvcForHosts("example.com", "example.org")
-			.build()
+	// Not possible in Kotlin until {kotlin-issues}/KT-22208 is fixed
 ----
 ======
 

framework-docs/modules/ROOT/pages/testing/mockmvc/htmlunit/webdriver.adoc

@@ -203,7 +203,7 @@ Kotlin::
 ======
 
 NOTE: This is a simple example of using `MockMvcHtmlUnitDriverBuilder`. For more advanced
-usage, see <<mockmvc-server-htmlunit-webdriver-advanced-builder>>.
+usage, see xref:testing/mockmvc/htmlunit/webdriver.adoc#spring-mvc-test-server-htmlunit-webdriver-advanced-builder[Advanced `MockMvcHtmlUnitDriverBuilder`].
 
 The preceding example ensures that any URL that references `localhost` as the server is
 directed to our `MockMvc` instance without the need for a real HTTP connection. Any other
@@ -259,11 +259,10 @@ Kotlin::
 ======
 --
 
-This improves on the design of our
-xref:testing/mockmvc/htmlunit/mah.adoc#mockmvc-server-htmlunit-mah-usage[HtmlUnit test]
+This improves on the design of our xref:testing/mockmvc/htmlunit/mah.adoc#spring-mvc-test-server-htmlunit-mah-usage[HtmlUnit test]
 by leveraging the Page Object Pattern. As we mentioned in
-<<mockmvc-server-htmlunit-webdriver-why>>, we can use the Page Object Pattern with
-HtmlUnit, but it is much easier with WebDriver. Consider the following
+xref:testing/mockmvc/htmlunit/webdriver.adoc#mockmvc-server-htmlunit-webdriver-why[Why WebDriver and MockMvc?], we can use the Page Object Pattern
+with HtmlUnit, but it is much easier with WebDriver. Consider the following
 `CreateMessagePage` implementation:
 
 --
@@ -563,19 +562,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	val mockMvc: MockMvc = MockMvcBuilders
-			.webAppContextSetup(context)
-			.apply<DefaultMockMvcBuilder>(springSecurity())
-			.build()
-
-	driver = MockMvcHtmlUnitDriverBuilder
-			.mockMvcSetup(mockMvc)
-			// for illustration only - defaults to ""
-			.contextPath("")
-			// By default MockMvc is used for localhost only;
-			// the following will use MockMvc for example.com and example.org as well
-			.useMockMvcForHosts("example.com", "example.org")
-			.build()
+	// Not possible in Kotlin until {kotlin-issues}/KT-22208 is fixed
 ----
 ======
 

framework-docs/modules/ROOT/pages/testing/mockmvc/htmlunit/why.adoc

@@ -60,7 +60,7 @@ assume our form looks like the following snippet:
 	</form>
 ----
 
-How do we ensure that our form produces the correct request to create a new message? A
+How do we ensure that our form produce the correct request to create a new message? A
 naive attempt might resemble the following:
 
 [tabs]
@@ -154,7 +154,7 @@ validation.
 [[mockmvc-server-htmlunit-why-integration]]
 == Integration Testing to the Rescue?
 
-To resolve the issues mentioned above, we could perform end-to-end integration testing,
+To resolve the issues mentioned earlier, we could perform end-to-end integration testing,
 but this has some drawbacks. Consider testing the view that lets us page through the
 messages. We might need the following tests:
 
@@ -171,7 +171,7 @@ leads to a number of additional challenges:
 * Testing can become slow, since each test would need to ensure that the database is in
   the correct state.
 * Since our database needs to be in a specific state, we cannot run tests in parallel.
-* Performing assertions on items such as auto-generated IDs, timestamps, and others can
+* Performing assertions on such items as auto-generated IDs, timestamps, and others can
   be difficult.
 
 These challenges do not mean that we should abandon end-to-end integration testing

framework-docs/modules/ROOT/pages/testing/resttestclient.adoc

@@ -10,7 +10,7 @@ applications without a running server via MockMvc.
 
 
 
-[[resttestclient.setup]]
+[[resttestclient-setup]]
 == Setup
 
 To set up a `RestTestClient` you need to choose a server setup to bind to. This can be one
@@ -18,7 +18,7 @@ of several MockMvc setup choices, or a connection to a live server.
 
 
 
-[[resttestclient.controller-config]]
+[[resttestclient-controller-config]]
 === Bind to Controller
 
 This setup allows you to test specific controller(s) via mock request and response objects,
@@ -42,17 +42,55 @@ Kotlin::
 ----
 ======
 
-[[resttestclient.context-config]]
+[[resttestclient-context-config]]
 === Bind to `ApplicationContext`
 
 This setup allows you to load Spring configuration with Spring MVC
 infrastructure and controller declarations and use it to handle requests via mock request
 and response objects, without a running server.
 
-include-code::./RestClientContextTests[indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@SpringJUnitConfig(WebConfig.class) // <1>
+	class MyTests {
 
+		RestTestClient client;
 
-[[resttestclient.fn-config]]
+		@BeforeEach
+		void setUp(ApplicationContext context) {  // <2>
+			client = RestTestClient.bindToApplicationContext(context).build(); // <3>
+		}
+	}
+----
+<1> Specify the configuration to load
+<2> Inject the configuration
+<3> Create the `RestTestClient`
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@SpringJUnitConfig(WebConfig::class) // <1>
+	class MyTests {
+
+		lateinit var client: RestTestClient
+
+		@BeforeEach
+		fun setUp(context: ApplicationContext) { // <2>
+			client = RestTestClient.bindToApplicationContext(context).build() // <3>
+		}
+	}
+----
+<1> Specify the configuration to load
+<2> Inject the configuration
+<3> Create the `RestTestClient`
+======
+
+[[resttestclient-fn-config]]
 === Bind to Router Function
 
 This setup allows you to test xref:web/webmvc-functional.adoc[functional endpoints] via
@@ -77,7 +115,7 @@ Kotlin::
 ----
 ======
 
-[[resttestclient.server-config]]
+[[resttestclient-server-config]]
 === Bind to Server
 
 This setup connects to a running server to perform full, end-to-end HTTP tests:
@@ -101,7 +139,7 @@ Kotlin::
 
 
 
-[[resttestclient.client-config]]
+[[resttestclient-client-config]]
 === Client Config
 
 In addition to the server setup options described earlier, you can also configure client
@@ -132,34 +170,75 @@ Kotlin::
 
 
 
-[[resttestclient.tests]]
+[[resttestclient-tests]]
 == Writing Tests
 
-xref:integration/rest-clients.adoc#rest-restclient[`RestClient`] and `RestTestClient` have
-the same API up to the point of the call to `exchange()`. After that, `RestTestClient`
-provides two alternative ways to verify the response:
+`RestTestClient` provides an API identical to xref:integration/rest-clients.adoc#rest-restclient[`RestClient`]
+up to the point of performing a request by using `exchange()`.
 
-1. xref:resttestclient-workflow[Built-in Assertions] extend the request workflow with a chain of expectations
-2. xref:resttestclient-assertj[AssertJ Integration] to verify the response via `assertThat()` statements
+After the call to `exchange()`, `RestTestClient` diverges from `RestClient`, and
+instead continues with a workflow to verify responses.
 
+To assert the response status and headers, use the following:
 
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons/1")
+		.accept(MediaType.APPLICATION_JSON)
+		.exchange()
+		.expectStatus().isOk()
+		.expectHeader().contentType(MediaType.APPLICATION_JSON);
+----
 
-[[resttestclient.workflow]]
-=== Built-in Assertions
-
-To use the built-in assertions, remain in the workflow after the call to `exchange()`, and
-use one of the expectation methods. For example:
-
-include-code::./RestClientWorkflowTests[tag=test,indent=0]
-
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons/1")
+		.accept(MediaType.APPLICATION_JSON)
+		.exchange()
+		.expectStatus().isOk()
+		.expectHeader().contentType(MediaType.APPLICATION_JSON)
+----
+======
 
 If you would like for all expectations to be asserted even if one of them fails, you can
 use `expectAll(..)` instead of multiple chained `expect*(..)` calls. This feature is
 similar to the _soft assertions_ support in AssertJ and the `assertAll()` support in
 JUnit Jupiter.
 
-include-code::./RestClientWorkflowTests[tag=soft-assertions,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons/1")
+		.accept(MediaType.APPLICATION_JSON)
+		.exchange()
+		.expectAll(
+			spec -> spec.expectStatus().isOk(),
+			spec -> spec.expectHeader().contentType(MediaType.APPLICATION_JSON)
+		);
+----
 
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons/1")
+		.accept(MediaType.APPLICATION_JSON)
+		.exchange()
+		.expectAll(
+			{ spec -> spec.expectStatus().isOk() },
+			{ spec -> spec.expectHeader().contentType(MediaType.APPLICATION_JSON) }
+		)
+----
+======
 
 You can then choose to decode the response body through one of the following:
 
@@ -170,60 +249,186 @@ You can then choose to decode the response body through one of the following:
 If the built-in assertions are insufficient, you can consume the object instead and
 perform any other assertions:
 
-include-code::./RestClientWorkflowTests[tag=consume,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+    client.get().uri("/persons/1")
+            .exchange()
+            .expectStatus().isOk()
+            .expectBody(Person.class)
+            .consumeWith(result -> {
+                // custom assertions (for example, AssertJ)...
+            });
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons/1")
+			.exchange()
+			.expectStatus().isOk()
+			.expectBody<Person>()
+			.consumeWith {
+				// custom assertions (for example, AssertJ)...
+			}
+----
+======
 
 Or you can exit the workflow and obtain a `EntityExchangeResult`:
 
-include-code::./RestClientWorkflowTests[tag=result,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	EntityExchangeResult<Person> result = client.get().uri("/persons/1")
+			.exchange()
+			.expectStatus().isOk()
+			.expectBody(Person.class)
+			.returnResult();
+----
 
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	val result = client.get().uri("/persons/1")
+			.exchange()
+			.expectStatus().isOk
+			.expectBody<Person>()
+			.returnResult()
+----
+======
 
 TIP: When you need to decode to a target type with generics, look for the overloaded methods
 that accept {spring-framework-api}/core/ParameterizedTypeReference.html[`ParameterizedTypeReference`]
 instead of `Class<T>`.
 
 
-[[resttestclient.no-content]]
-==== No Content
+
+[[resttestclient-no-content]]
+=== No Content
 
 If the response is not expected to have content, you can assert that as follows:
 
-include-code::./NoContentTests[tag=emptyBody,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	client.post().uri("/persons")
+			.body(person)
+			.exchange()
+			.expectStatus().isCreated()
+			.expectBody().isEmpty();
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	client.post().uri("/persons")
+			.body(person)
+			.exchange()
+			.expectStatus().isCreated()
+			.expectBody().isEmpty()
+----
+======
 
 If you want to ignore the response content, the following releases the content without any assertions:
 
-include-code::./NoContentTests[tag=ignoreBody,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons/123")
+			.exchange()
+			.expectStatus().isNotFound()
+			.expectBody(Void.class);
+----
 
-NOTE: Consuming the response body (for example, with `expectBody`) is required if your tests are running with
-leak detection for pooled buffers. Without that, the tool will report buffers being leaked.
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons/123")
+			.exchange()
+			.expectStatus().isNotFound
+			.expectBody<Unit>()
+----
+======
 
 
-[[resttestclient.json]]
-==== JSON Content
+
+[[resttestclient-json]]
+=== JSON Content
 
 You can use `expectBody()` without a target type to perform assertions on the raw
 content rather than through higher level Object(s).
 
 To verify the full JSON content with https://jsonassert.skyscreamer.org[JSONAssert]:
 
-include-code::./JsonTests[tag=jsonBody,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons/1")
+			.exchange()
+			.expectStatus().isOk()
+			.expectBody()
+			.json("{\"name\":\"Jane\"}")
+----
 
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons/1")
+			.exchange()
+			.expectStatus().isOk()
+			.expectBody()
+			.json("{\"name\":\"Jane\"}")
+----
+======
 
 To verify JSON content with https://github.com/jayway/JsonPath[JSONPath]:
 
-include-code::./JsonTests[tag=jsonPath,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons")
+			.exchange()
+			.expectStatus().isOk()
+			.expectBody()
+			.jsonPath("$[0].name").isEqualTo("Jane")
+			.jsonPath("$[1].name").isEqualTo("Jason");
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	client.get().uri("/persons")
+			.exchange()
+			.expectStatus().isOk()
+			.expectBody()
+			.jsonPath("$[0].name").isEqualTo("Jane")
+			.jsonPath("$[1].name").isEqualTo("Jason")
+----
+======
 
 
-[[resttestclient.assertj]]
-=== AssertJ Integration
 
-`RestTestClientResponse` is the main entry point for the AssertJ integration.
-It is an `AssertProvider` that wraps the `ResponseSpec` of an exchange in order to enable
-use of `assertThat()` statements. For example:
-
-include-code::./AssertJTests[tag=withSpec,indent=0]
-
-
-You can also use the built-in workflow first, and then obtain an `ExchangeResult` to wrap
-and continue with AssertJ. For example:
-
-include-code::./AssertJTests[tag=withResult,indent=0]

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

@@ -43,16 +43,6 @@ alternative, you can set the same property via the
 xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
 ====
 
-[TIP]
-====
-JPA's `@PersistenceContext` and `@PersistenceUnit` annotations cannot be used to perform
-dependency injection within test classes in AOT mode.
-
-However, as of Spring Framework 7.0, you can inject an `EntityManager` or
-`EntityManagerFactory` into tests using `@Autowired` instead of `@PersistenceContext` and
-`@PersistenceUnit`, respectively.
-====
-
 [NOTE]
 ====
 The `@ContextHierarchy` annotation is not supported in AOT mode.

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

@@ -62,6 +62,17 @@ script by setting a JVM system property named `spring.test.context.cache.maxSize
 alternative, you can set the same property via the
 xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
 
+As of Spring Framework 7.0, an application context stored in the context cache will be
+_paused_ when it is no longer actively in use and automatically _restarted_ the next time
+the context is retrieved from the cache. Specifically, the latter will restart all
+auto-startup beans in the application context, effectively restoring the lifecycle state.
+This ensures that background processes within the context are not actively running while
+the context is not used by tests. For example, JMS listener containers, scheduled tasks,
+and any other components in the context that implement `Lifecycle` or `SmartLifecycle`
+will be in a "stopped" state until the context is used again by a test. Note, however,
+that `SmartLifecycle` components can opt out of pausing by returning `false` from
+`SmartLifecycle#isPauseable()`.
+
 Since having a large number of application contexts loaded within a given test suite can
 cause the suite to take an unnecessarily long time to run, it is often beneficial to
 know exactly how many contexts have been loaded and cached. To view the statistics for

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

@@ -1,45 +0,0 @@
-[[testcontext-ctx-management-pausing]]
-= Context Pausing
-
-As of Spring Framework 7.0, an `ApplicationContext` stored in the context cache (see
-xref:testing/testcontext-framework/ctx-management/caching.adoc[Context Caching]) may be
-_paused_ when it is no longer actively in use and automatically _restarted_ the next time
-the context is retrieved from the cache. Specifically, the latter will restart all
-auto-startup beans in the application context, effectively restoring the lifecycle state.
-This ensures that background processes within the context are not actively running while
-the context is not used by tests. For example, JMS listener containers, scheduled tasks,
-and any other components in the context that implement `Lifecycle` or `SmartLifecycle`
-will be in a "stopped" state until the context is used again by a test. Note, however,
-that `SmartLifecycle` components can opt out of pausing by returning `false` from
-`SmartLifecycle#isPauseable()`.
-
-You can control whether inactive application contexts should be paused by setting the
-`PauseMode` to one of the following supported values.
-
-`ALWAYS` :: Always pause inactive application contexts.
-`ON_CONTEXT_SWITCH` :: Only pause inactive application contexts if the next context
-  retrieved from the context cache is a different context.
-`NEVER` :: Never pause inactive application contexts, effectively disabling the pausing
-  feature of the context cache.
-
-The `PauseMode` defaults to `ON_CONTEXT_SWITCH`, but it can be changed from the command
-line or a build script by setting a JVM system property named
-`spring.test.context.cache.pause` to one of the supported values (case insensitive). As
-an alternative, you can set the property via the
-xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
-
-For example, if you want inactive application contexts to always be paused, you can
-switch from the default `ON_CONTEXT_SWITCH` mode to `ALWAYS` by setting the
-`spring.test.context.cache.pause` system property to `always`.
-
-```shell
--Dspring.test.context.cache.pause=always
-```
-Similarly, if you encounter issues with `Lifecycle` components that cannot or should not
-opt out of pausing, or if you discover that your test suite runs more slowly due to the
-pausing and restarting of application contexts, you can disable the pausing feature by
-setting the `spring.test.context.cache.pause` system property to `never`.
-
-```shell
--Dspring.test.context.cache.pause=never
-```

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

@@ -8,15 +8,12 @@ in JUnit and TestNG.
 [[testcontext-junit-jupiter-extension]]
 == SpringExtension for JUnit Jupiter
 
-The `SpringExtension` integrates the Spring TestContext Framework into the JUnit Jupiter
-testing framework.
-
-NOTE: As of Spring Framework 7.0, the `SpringExtension` requires JUnit Jupiter 6.0 or higher.
-
-By annotating test classes with `@ExtendWith(SpringExtension.class)`, you can implement
-standard JUnit Jupiter-based unit and integration tests and simultaneously reap the
-benefits of the TestContext framework, such as support for loading application contexts,
-dependency injection of test instances, transactional test method execution, and so on.
+The Spring TestContext Framework offers full integration with the JUnit Jupiter testing
+framework, originally introduced in JUnit 5. By annotating test classes with
+`@ExtendWith(SpringExtension.class)`, you can implement standard JUnit Jupiter-based unit
+and integration tests and simultaneously reap the benefits of the TestContext framework,
+such as support for loading application contexts, dependency injection of test instances,
+transactional test method execution, and so on.
 
 Furthermore, thanks to the rich extension API in JUnit Jupiter, Spring provides the
 following features above and beyond the feature set that Spring supports for JUnit 4 and
@@ -25,7 +22,7 @@ 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.
-* Powerful support for link:https://docs.junit.org/current/user-guide/#extensions-conditions[conditional
+* 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
   xref:testing/annotations/integration-junit-jupiter.adoc[Spring JUnit Jupiter Testing Annotations]
@@ -163,7 +160,7 @@ for further details.
 === Dependency Injection with the `SpringExtension`
 
 The `SpringExtension` implements the
-link:https://docs.junit.org/current/user-guide/#extensions-parameter-resolution[`ParameterResolver`]
+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.
 

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

@@ -309,7 +309,7 @@ before-transaction method or after-transaction method runs at the appropriate ti
 Generally speaking, `@BeforeTransaction` and `@AfterTransaction` methods must not accept
 any arguments.
 
-However, for tests using the
+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`
@@ -362,7 +362,7 @@ of `PlatformTransactionManager` within the test's `ApplicationContext`, you can
 qualifier by using `@Transactional("myTxMgr")` or `@Transactional(transactionManager =
 "myTxMgr")`, or `TransactionManagementConfigurer` can be implemented by an
 `@Configuration` class. Consult the
-{spring-framework-api}/test/context/transaction/TestContextTransactionUtils.html#retrieveTransactionManager(org.springframework.test.context.TestContext,java.lang.String)[javadoc
+{spring-framework-api}/test/context/transaction/TestContextTransactionUtils.html#retrieveTransactionManager-org.springframework.test.context.TestContext-java.lang.String-[javadoc
 for `TestContextTransactionUtils.retrieveTransactionManager()`] for details on the
 algorithm used to look up a transaction manager in the test's `ApplicationContext`.
 

framework-docs/modules/ROOT/pages/testing/unit.adoc

@@ -46,8 +46,8 @@ mock objects that are useful for testing web contexts, controllers, and filters.
 mock objects are targeted at usage with Spring's Web MVC framework and are generally more
 convenient to use than dynamic mock objects (such as https://easymock.org/[EasyMock]).
 
-TIP: Since Spring Framework 7.0, the mock objects in `org.springframework.mock.web` are
-based on the Servlet 6.1 API.
+TIP: Since Spring Framework 6.0, the mock objects in `org.springframework.mock.web` are
+based on the Servlet 6.0 API.
 
 MockMvc builds on the mock Servlet API objects to provide an integration testing
 framework for Spring MVC. See xref:testing/mockmvc.adoc[MockMvc].

framework-docs/modules/ROOT/pages/testing/webtestclient.adoc

@@ -75,7 +75,7 @@ infrastructure and controller declarations and use it to handle requests via moc
 and response objects, without a running server.
 
 For WebFlux, use the following where the Spring `ApplicationContext` is passed to
-{spring-framework-api}/web/server/adapter/WebHttpHandlerBuilder.html#applicationContext(org.springframework.context.ApplicationContext)[WebHttpHandlerBuilder]
+{spring-framework-api}/web/server/adapter/WebHttpHandlerBuilder.html#applicationContext-org.springframework.context.ApplicationContext-[WebHttpHandlerBuilder]
 to create the xref:web/webflux/reactive-spring.adoc#webflux-web-handler-api[WebHandler chain] to handle
 requests:
 
@@ -270,26 +270,16 @@ Kotlin::
 ======
 
 
-
-
 [[webtestclient-tests]]
 == Writing Tests
 
-xref:web/webflux-webclient.adoc[WebClient] and `WebTestClient` have
-the same API up to the point of the call to `exchange()`. After that, `WebTestClient`
-provides two alternative ways to verify the response:
+`WebTestClient` provides an API identical to xref:web/webflux-webclient.adoc[WebClient]
+up to the point of performing a request by using `exchange()`. See the
+xref:web/webflux-webclient/client-body.adoc[WebClient] documentation for examples on how to
+prepare a request with any content including form data, multipart data, and more.
 
-1. xref:webtestclient-workflow[Built-in Assertions] extend the request workflow with a chain of expectations
-2. xref:webtestclient-assertj[AssertJ Integration] to verify the response via `assertThat()` statements
-
-TIP: See the xref:web/webflux-webclient/client-body.adoc[WebClient] documentation for
-examples on how to prepare a request with any content including form data,
-multipart data, and more.
-
-
-
-[[webtestclient-workflow]]
-=== Built-in Assertions
+After the call to `exchange()`, `WebTestClient` diverges from the `WebClient` and
+instead continues with a workflow to verify responses.
 
 To assert the response status and headers, use the following:
 
@@ -453,10 +443,8 @@ that accept
 {spring-framework-api}/core/ParameterizedTypeReference.html[`ParameterizedTypeReference`]
 instead of `Class<T>`.
 
-
-
 [[webtestclient-no-content]]
-==== No Content
+=== No Content
 
 If the response is not expected to have content, you can assert that as follows:
 
@@ -511,10 +499,8 @@ Kotlin::
 ----
 ======
 
-
-
 [[webtestclient-json]]
-==== JSON Content
+=== JSON Content
 
 You can use `expectBody()` without a target type to perform assertions on the raw
 content rather than through higher level Object(s).
@@ -575,10 +561,8 @@ Kotlin::
 ----
 ======
 
-
-
 [[webtestclient-stream]]
-==== Streaming Responses
+=== Streaming Responses
 
 To test potentially infinite streams such as `"text/event-stream"` or
 `"application/x-ndjson"`, start by verifying the response status and headers, and then
@@ -645,78 +629,6 @@ Kotlin::
 ----
 ======
 
-
-
-[[webtestclient-assertj]]
-=== AssertJ Integration
-
-`WebTestClientResponse` is the main entry point for the AssertJ integration.
-It is an `AssertProvider` that wraps the `ResponseSpec` of an exchange in order to enable
-use of `assertThat()` statements. For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	ResponseSpec spec = client.get().uri("/persons").exchange();
-
-	WebTestClientResponse response = WebTestClientResponse.from(spec);
-	assertThat(response).hasStatusOk();
-	assertThat(response).hasContentTypeCompatibleWith(MediaType.TEXT_PLAIN);
-	// ...
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
-----
-	val spec = client.get().uri("/persons").exchange()
-
-	val response = WebTestClientResponse.from(spec)
-	assertThat(response).hasStatusOk()
-	assertThat(response).hasContentTypeCompatibleWith(MediaType.TEXT_PLAIN)
-	// ...
-----
-======
-
-You can also use the built-in workflow first, and then obtain an `ExchangeResult` to wrap
-and continue with AssertJ. For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	ExchangeResult result = client.get().uri("/persons").exchange()
-			. // ...
-			.returnResult();
-
-	WebTestClientResponse response = WebTestClientResponse.from(result);
-	assertThat(response).hasStatusOk();
-	assertThat(response).hasContentTypeCompatibleWith(MediaType.TEXT_PLAIN);
-	// ...
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
-----
-	val result = client.get().uri("/persons").exchange()
-			. // ...
-			.returnResult()
-
-	val response = WebTestClientResponse.from(spec)
-	assertThat(response).hasStatusOk()
-	assertThat(response).hasContentTypeCompatibleWith(MediaType.TEXT_PLAIN)
-	// ...
-----
-======
-
-
-
 [[webtestclient-mockmvc]]
 === MockMvc Assertions
 

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

@@ -0,0 +1,186 @@
+[[web-integration]]
+= Other Web Frameworks
+
+This chapter details Spring's integration with third-party web frameworks.
+
+One of the core value propositions of the Spring Framework is that of enabling
+_choice_. In a general sense, Spring does not force you to use or buy into any
+particular architecture, technology, or methodology (although it certainly recommends
+some over others). This freedom to pick and choose the architecture, technology, or
+methodology that is most relevant to a developer and their development team is
+arguably most evident in the web area, where Spring provides its own web frameworks
+(xref:web/webmvc.adoc#mvc[Spring MVC] and xref:web/webflux.adoc#webflux[Spring WebFlux])
+while, at the same time, supporting integration with a number of popular third-party
+web frameworks.
+
+
+[[web-integration-common]]
+== Common Configuration
+
+Before diving into the integration specifics of each supported web framework, let us
+first take a look at common Spring configuration that is not specific to any one web
+framework. (This section is equally applicable to Spring's own web framework variants.)
+
+One of the concepts (for want of a better word) espoused by Spring's lightweight
+application model is that of a layered architecture. Remember that in a "classic"
+layered architecture, the web layer is but one of many layers. It serves as one of the
+entry points into a server-side application, and it delegates to service objects
+(facades) that are defined in a service layer to satisfy business-specific (and
+presentation-technology agnostic) use cases. In Spring, these service objects, any other
+business-specific objects, data-access objects, and others exist in a distinct "business
+context", which contains no web or presentation layer objects (presentation objects,
+such as Spring MVC controllers, are typically configured in a distinct "presentation
+context"). This section details how you can configure a Spring container (a
+`WebApplicationContext`) that contains all of the 'business beans' in your application.
+
+Moving on to specifics, all you need to do is declare a
+{spring-framework-api}/web/context/ContextLoaderListener.html[`ContextLoaderListener`]
+in the standard Jakarta EE servlet `web.xml` file of your web application and add a
+`contextConfigLocation` `<context-param/>` section (in the same file) that defines which
+set of Spring XML configuration files to load.
+
+Consider the following `<listener/>` configuration:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<listener>
+		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
+	</listener>
+----
+
+Further consider the following `<context-param/>` configuration:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<context-param>
+		<param-name>contextConfigLocation</param-name>
+		<param-value>/WEB-INF/applicationContext*.xml</param-value>
+	</context-param>
+----
+
+If you do not specify the `contextConfigLocation` context parameter, the
+`ContextLoaderListener` looks for a file called `/WEB-INF/applicationContext.xml` to
+load. Once the context files are loaded, Spring creates a
+{spring-framework-api}/web/context/WebApplicationContext.html[`WebApplicationContext`]
+object based on the bean definitions and stores it in the `ServletContext` of the web
+application.
+
+All Java web frameworks are built on top of the Servlet API, so you can use the
+following code snippet to get access to this "business context" `ApplicationContext`
+created by the `ContextLoaderListener`.
+
+The following example shows how to get the `WebApplicationContext`:
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);
+----
+
+The
+{spring-framework-api}/web/context/support/WebApplicationContextUtils.html[`WebApplicationContextUtils`]
+class is for convenience, so you need not remember the name of the `ServletContext`
+attribute. Its `getWebApplicationContext()` method returns `null` if an object
+does not exist under the `WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE`
+key. Rather than risk getting `NullPointerExceptions` in your application, it is better
+to use the `getRequiredWebApplicationContext()` method. This method throws an exception
+when the `ApplicationContext` is missing.
+
+Once you have a reference to the `WebApplicationContext`, you can retrieve beans by their
+name or type. Most developers retrieve beans by name and then cast them to one of their
+implemented interfaces.
+
+Fortunately, most of the frameworks in this section have simpler ways of looking up beans.
+Not only do they make it easy to get beans from a Spring container, but they also let you
+use dependency injection on their controllers. Each web framework section has more detail
+on its specific integration strategies.
+
+
+[[jsf]]
+== JSF
+
+JavaServer Faces (JSF) is the JCP's standard component-based, event-driven web
+user interface framework. It is an official part of the Jakarta EE umbrella but also
+individually usable, for example, through embedding Mojarra or MyFaces within Tomcat.
+
+Please note that recent versions of JSF became closely tied to CDI infrastructure
+in application servers, with some new JSF functionality only working in such an
+environment. Spring's JSF support is not actively evolved anymore and primarily
+exists for migration purposes when modernizing older JSF-based applications.
+
+The key element in Spring's JSF integration is the JSF `ELResolver` mechanism.
+
+[[jsf-springbeanfaceselresolver]]
+=== Spring Bean Resolver
+
+`SpringBeanFacesELResolver` is a JSF compliant `ELResolver` implementation,
+integrating with the standard Unified EL as used by JSF and JSP. It delegates to
+Spring's "business context" `WebApplicationContext` first and then to the
+default resolver of the underlying JSF implementation.
+
+Configuration-wise, you can define `SpringBeanFacesELResolver` in your JSF
+`faces-context.xml` file, as the following example shows:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<faces-config>
+		<application>
+			<el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver</el-resolver>
+			...
+		</application>
+	</faces-config>
+----
+
+[[jsf-facescontextutils]]
+=== Using `FacesContextUtils`
+
+A custom `ELResolver` works well when mapping your properties to beans in
+`faces-config.xml`, but, at times, you may need to explicitly grab a bean.
+The {spring-framework-api}/web/jsf/FacesContextUtils.html[`FacesContextUtils`]
+class makes this easy. It is similar to `WebApplicationContextUtils`, except that
+it takes a `FacesContext` parameter rather than a `ServletContext` parameter.
+
+The following example shows how to use `FacesContextUtils`:
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	ApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());
+----
+
+
+[[struts]]
+== Apache Struts
+
+Invented by Craig McClanahan, https://struts.apache.org[Struts] is an open-source project
+hosted by the Apache Software Foundation. Struts 1.x greatly simplified the
+JSP/Servlet programming paradigm and won over many developers who were using proprietary
+frameworks. It simplified the programming model; it was open source; and it had a large
+community, which let the project grow and become popular among Java web developers.
+
+As a successor to the original Struts 1.x, check out Struts 2.x or more recent versions
+as well as the Struts-provided
+https://struts.apache.org/plugins/spring/[Spring Plugin] for built-in Spring integration.
+
+
+[[tapestry]]
+== Apache Tapestry
+
+https://tapestry.apache.org/[Tapestry] is a "Component oriented framework for creating
+dynamic, robust, highly scalable web applications in Java."
+
+While Spring has its own xref:web/webmvc.adoc#mvc[powerful web layer], there are a number of unique
+advantages to building an enterprise Java application by using a combination of Tapestry
+for the web user interface and the Spring container for the lower layers.
+
+For more information, see Tapestry's dedicated
+https://tapestry.apache.org/integrating-with-spring-framework.html[integration module for Spring].
+
+
+[[web-integration-resources]]
+== Further Resources
+
+The following links go to further resources about the various web frameworks described in
+this chapter.
+
+* The https://www.oracle.com/java/technologies/javaserverfaces.html[JSF] homepage
+* The https://struts.apache.org/[Struts] homepage
+* The https://tapestry.apache.org/[Tapestry] homepage

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

@@ -44,7 +44,7 @@ rejected. No CORS headers are added to the responses of simple and actual CORS r
 and, consequently, browsers reject them.
 
 Each `HandlerMapping` can be
-{spring-framework-api}/web/reactive/handler/AbstractHandlerMapping.html#setCorsConfigurations(java.util.Map)[configured]
+{spring-framework-api}/web/reactive/handler/AbstractHandlerMapping.html#setCorsConfigurations-java.util.Map-[configured]
 individually with URL pattern-based `CorsConfiguration` mappings. In most cases, applications
 use the WebFlux Java configuration to declare such mappings, which results in a single,
 global map passed to all `HandlerMapping` implementations.
@@ -57,7 +57,7 @@ class- or method-level `@CrossOrigin` annotations (other handlers can implement
 The rules for combining global and local configuration are generally additive -- for example,
 all global and all local origins. For those attributes where only a single value can be
 accepted, such as `allowCredentials` and `maxAge`, the local overrides the global value. See
-{spring-framework-api}/web/cors/CorsConfiguration.html#combine(org.springframework.web.cors.CorsConfiguration)[`CorsConfiguration#combine(CorsConfiguration)`]
+{spring-framework-api}/web/cors/CorsConfiguration.html#combine-org.springframework.web.cors.CorsConfiguration-[`CorsConfiguration#combine(CorsConfiguration)`]
 for more details.
 
 [TIP]
@@ -305,6 +305,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
+	@EnableWebFlux
 	public class WebConfig implements WebFluxConfigurer {
 
 		@Override
@@ -327,6 +328,7 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
+	@EnableWebFlux
 	class WebConfig : WebFluxConfigurer {
 
 		override fun addCorsMappings(registry: CorsRegistry) {

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

@@ -123,7 +123,7 @@ Both request and response provide {reactive-streams-site}[Reactive Streams] back
 against the body streams.
 The request body is represented with a Reactor `Flux` or `Mono`.
 The response body is represented with any Reactive Streams `Publisher`, including `Flux` and `Mono`.
-For more on that, see xref:web/webflux-reactive-libraries.adoc[Reactive Libraries].
+For more on that, see xref:web-reactive.adoc#webflux-reactive-libraries[Reactive Libraries].
 
 [[webflux-fn-request]]
 === ServerRequest
@@ -235,14 +235,87 @@ val map = request.awaitMultipartData()
 
 The following example shows how to access multipart data, one at a time, in streaming fashion:
 
-include-code::./PartEventHandler[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+Flux<PartEvent> allPartEvents = request.bodyToFlux(PartEvent.class);
+allPartsEvents.windowUntil(PartEvent::isLast)
+      .concatMap(p -> p.switchOnFirst((signal, partEvents) -> {
+          if (signal.hasValue()) {
+              PartEvent event = signal.get();
+              if (event instanceof FormPartEvent formEvent) {
+                  String value = formEvent.value();
+                  // handle form field
+              }
+              else if (event instanceof FilePartEvent fileEvent) {
+                  String filename = fileEvent.filename();
+                  Flux<DataBuffer> contents = partEvents.map(PartEvent::content);
+                  // handle file upload
+              }
+              else {
+                  return Mono.error(new RuntimeException("Unexpected event: " + event));
+              }
+          }
+          else {
+              return partEvents; // either complete or error signal
+          }
+      }));
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+val parts = request.bodyToFlux<PartEvent>()
+allPartsEvents.windowUntil(PartEvent::isLast)
+    .concatMap {
+        it.switchOnFirst { signal, partEvents ->
+            if (signal.hasValue()) {
+                val event = signal.get()
+                if (event is FormPartEvent) {
+                    val value: String = event.value();
+                    // handle form field
+                } else if (event is FilePartEvent) {
+                    val filename: String = event.filename();
+                    val contents: Flux<DataBuffer> = partEvents.map(PartEvent::content);
+                    // handle file upload
+                } else {
+                    return Mono.error(RuntimeException("Unexpected event: " + event));
+                }
+            } else {
+                return partEvents; // either complete or error signal
+            }
+        }
+    }
+}
+----
+======
 
 NOTE: The body contents of the `PartEvent` objects must be completely consumed, relayed, or released to avoid memory leaks.
 
-The following shows how to bind request parameters, URI variables, or headers via `DataBinder`,
-and also shows how to customize the `DataBinder`:
+The following shows how to bind request parameters, including an optional `DataBinder` customization:
+
+[tabs]
+======
+Java::
++
+[source,java]
+----
+Pet pet = request.bind(Pet.class, dataBinder -> dataBinder.setAllowedFields("name"));
+----
+
+Kotlin::
++
+[source,kotlin]
+----
+val pet = request.bind(Pet::class.java, {dataBinder -> dataBinder.setAllowedFields("name")})
+----
+======
+
 
-include-code::./RequestHandler[tag=snippet,indent=0]
 
 [[webflux-fn-response]]
 === ServerResponse
@@ -252,7 +325,24 @@ a `build` method to create it. You can use the builder to set the response statu
 headers, or to provide a body. The following example creates a 200 (OK) response with JSON
 content:
 
-include-code::./ResponseHandler[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java]
+----
+Mono<Person> person = ...
+ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person, Person.class);
+----
+
+Kotlin::
++
+[source,kotlin]
+----
+val person: Person = ...
+ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyValue(person)
+----
+======
 
 The following example shows how to build a 201 (CREATED) response with a `Location` header and no body:
 
@@ -263,7 +353,7 @@ Java::
 [source,java]
 ----
 URI location = ...
-return ServerResponse.created(location).build();
+ServerResponse.created(location).build();
 ----
 
 Kotlin::
@@ -271,7 +361,7 @@ Kotlin::
 [source,kotlin]
 ----
 val location: URI = ...
-return ServerResponse.created(location).build()
+ServerResponse.created(location).build()
 ----
 ======
 
@@ -284,14 +374,14 @@ Java::
 +
 [source,java]
 ----
-return ServerResponse.ok().hint(JacksonCodecSupport.JSON_VIEW_HINT, MyJacksonView.class).body(...);
+ServerResponse.ok().hint(Jackson2CodecSupport.JSON_VIEW_HINT, MyJacksonView.class).body(...);
 ----
 
 Kotlin::
 +
 [source,kotlin]
 ----
-return ServerResponse.ok().hint(JacksonCodecSupport.JSON_VIEW_HINT, MyJacksonView::class.java).body(...)
+ServerResponse.ok().hint(Jackson2CodecSupport.JSON_VIEW_HINT, MyJacksonView::class.java).body(...)
 ----
 ======
 
@@ -326,7 +416,87 @@ Therefore, it is useful to group related handler functions together into a handl
 has a similar role as  `@Controller` in an annotation-based application.
 For example, the following class exposes a reactive `Person` repository:
 
-include-code::./PersonHandler[tag=snippet,indent=0]
+--
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.web.reactive.function.server.ServerResponse.ok;
+
+public class PersonHandler {
+
+	private final PersonRepository repository;
+
+	public PersonHandler(PersonRepository repository) {
+		this.repository = repository;
+	}
+
+	public Mono<ServerResponse> listPeople(ServerRequest request) { // <1>
+		Flux<Person> people = repository.allPeople();
+		return ok().contentType(APPLICATION_JSON).body(people, Person.class);
+	}
+
+	public Mono<ServerResponse> createPerson(ServerRequest request) { // <2>
+		Mono<Person> person = request.bodyToMono(Person.class);
+		return ok().build(repository.savePerson(person));
+	}
+
+	public Mono<ServerResponse> getPerson(ServerRequest request) { // <3>
+		int personId = Integer.valueOf(request.pathVariable("id"));
+		return repository.getPerson(personId)
+			.flatMap(person -> ok().contentType(APPLICATION_JSON).bodyValue(person))
+			.switchIfEmpty(ServerResponse.notFound().build());
+	}
+}
+----
+<1> `listPeople` is a handler function that returns all `Person` objects found in the repository as
+JSON.
+<2> `createPerson` is a handler function that stores a new `Person` contained in the request body.
+Note that `PersonRepository.savePerson(Person)` returns `Mono<Void>`: an empty `Mono` that emits
+a completion signal when the person has been read from the request and stored. So we use the
+`build(Publisher<Void>)` method to send a response when that completion signal is received (that is,
+when the `Person` has been saved).
+<3> `getPerson` is a handler function that returns a single person, identified by the `id` path
+variable. We retrieve that `Person` from the repository and create a JSON response, if it is
+found. If it is not found, we use `switchIfEmpty(Mono<T>)` to return a 404 Not Found response.
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	class PersonHandler(private val repository: PersonRepository) {
+
+		suspend fun listPeople(request: ServerRequest): ServerResponse { // <1>
+			val people: Flow<Person> = repository.allPeople()
+			return ok().contentType(APPLICATION_JSON).bodyAndAwait(people);
+		}
+
+		suspend fun createPerson(request: ServerRequest): ServerResponse { // <2>
+			val person = request.awaitBody<Person>()
+			repository.savePerson(person)
+			return ok().buildAndAwait()
+		}
+
+		suspend fun getPerson(request: ServerRequest): ServerResponse { // <3>
+			val personId = request.pathVariable("id").toInt()
+			return repository.getPerson(personId)?.let { ok().contentType(APPLICATION_JSON).bodyValueAndAwait(it) }
+					?: ServerResponse.notFound().buildAndAwait()
+
+		}
+	}
+----
+<1> `listPeople` is a handler function that returns all `Person` objects found in the repository as
+JSON.
+<2> `createPerson` is a handler function that stores a new `Person` contained in the request body.
+Note that `PersonRepository.savePerson(Person)` is a suspending function with no return type.
+<3> `getPerson` is a handler function that returns a single person, identified by the `id` path
+variable. We retrieve that `Person` from the repository and create a JSON response, if it is
+found. If it is not found, we return a 404 Not Found response.
+======
+--
 
 [[webflux-fn-handler-validation]]
 === Validation
@@ -335,7 +505,66 @@ A functional endpoint can use Spring's xref:web/webmvc/mvc-config/validation.ado
 apply validation to the request body. For example, given a custom Spring
 xref:web/webmvc/mvc-config/validation.adoc[Validator] implementation for a `Person`:
 
-include-code::./PersonHandler[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	public class PersonHandler {
+
+		private final Validator validator = new PersonValidator(); // <1>
+
+		// ...
+
+		public Mono<ServerResponse> createPerson(ServerRequest request) {
+			Mono<Person> person = request.bodyToMono(Person.class).doOnNext(this::validate); // <2>
+			return ok().build(repository.savePerson(person));
+		}
+
+		private void validate(Person person) {
+			Errors errors = new BeanPropertyBindingResult(person, "person");
+			validator.validate(person, errors);
+			if (errors.hasErrors()) {
+				throw new ServerWebInputException(errors.toString()); // <3>
+			}
+		}
+	}
+----
+<1> Create `Validator` instance.
+<2> Apply validation.
+<3> Raise exception for a 400 response.
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	class PersonHandler(private val repository: PersonRepository) {
+
+		private val validator = PersonValidator() // <1>
+
+		// ...
+
+		suspend fun createPerson(request: ServerRequest): ServerResponse {
+			val person = request.awaitBody<Person>()
+			validate(person) // <2>
+			repository.savePerson(person)
+			return ok().buildAndAwait()
+		}
+
+		private fun validate(person: Person) {
+			val errors: Errors = BeanPropertyBindingResult(person, "person");
+			validator.validate(person, errors);
+			if (errors.hasErrors()) {
+				throw ServerWebInputException(errors.toString()) // <3>
+			}
+		}
+	}
+----
+<1> Create `Validator` instance.
+<2> Apply validation.
+<3> Raise exception for a 400 response.
+======
 
 Handlers can also use the standard bean validation API (JSR-303) by creating and injecting
 a global `Validator` instance based on `LocalValidatorFactoryBean`.
@@ -373,7 +602,28 @@ path, headers, xref:#api-version[API version], and more.
 
 The following example uses an `Accept` header, request predicate:
 
-include-code::./RouterConfiguration[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	RouterFunction<ServerResponse> route = RouterFunctions.route()
+		.GET("/hello-world", accept(MediaType.TEXT_PLAIN),
+			request -> ServerResponse.ok().bodyValue("Hello World")).build();
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	val route = coRouter {
+		GET("/hello-world", accept(TEXT_PLAIN)) {
+			ServerResponse.ok().bodyValueAndAwait("Hello World")
+		}
+	}
+----
+======
 
 You can compose multiple request predicates together by using:
 
@@ -408,7 +658,61 @@ There are also other ways to compose multiple router functions together:
 
 The following example shows the composition of four routes:
 
-include-code::./RouterConfiguration[tag=snippet,indent=0]
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.web.reactive.function.server.RequestPredicates.*;
+
+PersonRepository repository = ...
+PersonHandler handler = new PersonHandler(repository);
+
+RouterFunction<ServerResponse> otherRoute = ...
+
+RouterFunction<ServerResponse> route = route()
+	.GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson) // <1>
+	.GET("/person", accept(APPLICATION_JSON), handler::listPeople) // <2>
+	.POST("/person", handler::createPerson) // <3>
+	.add(otherRoute) // <4>
+	.build();
+----
+<1> pass:q[`GET /person/{id}`] with an `Accept` header that matches JSON is routed to
+`PersonHandler.getPerson`
+<2> `GET /person` with an `Accept` header that matches JSON is routed to
+`PersonHandler.listPeople`
+<3> `POST /person` with no additional predicates is mapped to
+`PersonHandler.createPerson`, and
+<4> `otherRoute` is a router function that is created elsewhere, and added to the route built.
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	import org.springframework.http.MediaType.APPLICATION_JSON
+
+	val repository: PersonRepository = ...
+	val handler = PersonHandler(repository);
+
+	val otherRoute: RouterFunction<ServerResponse> = coRouter {  }
+
+	val route = coRouter {
+		GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson) // <1>
+		GET("/person", accept(APPLICATION_JSON), handler::listPeople) // <2>
+		POST("/person", handler::createPerson) // <3>
+	}.and(otherRoute) // <4>
+----
+<1> pass:q[`GET /person/{id}`] with an `Accept` header that matches JSON is routed to
+`PersonHandler.getPerson`
+<2> `GET /person` with an `Accept` header that matches JSON is routed to
+`PersonHandler.listPeople`
+<3> `POST /person` with no additional predicates is mapped to
+`PersonHandler.createPerson`, and
+<4> `otherRoute` is a router function that is created elsewhere, and added to the route built.
+======
 
 [[nested-routes]]
 === Nested Routes
@@ -506,7 +810,7 @@ Java::
 ----
 	RouterFunction<ServerResponse> route = RouterFunctions.route()
 		.GET("/hello-world", version("1.2"),
-			request -> ServerResponse.ok().bodyValue("Hello World")).build();
+			request -> ServerResponse.ok().body("Hello World")).build();
 ----
 
 Kotlin::
@@ -639,6 +943,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
+	@EnableWebFlux
 	public class WebConfig implements WebFluxConfigurer {
 
 		@Bean
@@ -675,6 +980,7 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
+	@EnableWebFlux
 	class WebConfig : WebFluxConfigurer {
 
 		@Bean
@@ -742,9 +1048,9 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	val route = router {
-		("/person" and accept(APPLICATION_JSON)).nest {
+		"/person".nest {
 			GET("/{id}", handler::getPerson)
-			GET(handler::listPeople)
+			GET("", handler::listPeople)
 			before { // <1>
 				ServerRequest.from(it)
 						.header("X-RequestHeader", "Value").build()
@@ -771,7 +1077,54 @@ Now we can add a simple security filter to our route, assuming that we have a `S
 can determine whether a particular path is allowed.
 The following example shows how to do so:
 
-include-code::./RouterConfiguration[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	SecurityManager securityManager = ...
+
+	RouterFunction<ServerResponse> route = route()
+		.path("/person", b1 -> b1
+			.nest(accept(APPLICATION_JSON), b2 -> b2
+				.GET("/{id}", handler::getPerson)
+				.GET(handler::listPeople))
+			.POST(handler::createPerson))
+		.filter((request, next) -> {
+			if (securityManager.allowAccessTo(request.path())) {
+				return next.handle(request);
+			}
+			else {
+				return ServerResponse.status(UNAUTHORIZED).build();
+			}
+		})
+		.build();
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	val securityManager: SecurityManager = ...
+
+	val route = router {
+			("/person" and accept(APPLICATION_JSON)).nest {
+				GET("/{id}", handler::getPerson)
+				GET("", handler::listPeople)
+				POST(handler::createPerson)
+				filter { request, next ->
+					if (securityManager.allowAccessTo(request.path())) {
+						next(request)
+					}
+					else {
+						status(UNAUTHORIZED).build();
+					}
+				}
+			}
+		}
+----
+======
 
 The preceding example demonstrates that invoking the `next.handle(ServerRequest)` is optional.
 We only let the handler function be run when access is allowed.

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

@@ -56,7 +56,8 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
-	public class WebConfiguration implements WebFluxConfigurer {
+	@EnableWebFlux
+	public class WebConfig implements WebFluxConfigurer {
 
 		@Override
 		public void configureViewResolvers(ViewResolverRegistry registry) {
@@ -79,7 +80,8 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
-	class WebConfiguration : WebFluxConfigurer {
+	@EnableWebFlux
+	class WebConfig : WebFluxConfigurer {
 
 		override fun configureViewResolvers(registry: ViewResolverRegistry) {
 			registry.freeMarker()
@@ -117,7 +119,8 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
-	public class WebConfiguration implements WebFluxConfigurer {
+	@EnableWebFlux
+	public class WebConfig implements WebFluxConfigurer {
 
 		// ...
 
@@ -139,7 +142,8 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
-	class WebConfiguration : WebFluxConfigurer {
+	@EnableWebFlux
+	class WebConfig : WebFluxConfigurer {
 
 		// ...
 
@@ -206,8 +210,13 @@ The following table shows the templating libraries that we have tested on differ
 [%header]
 |===
 |Scripting Library |Scripting Engine
+|https://handlebarsjs.com/[Handlebars] |https://openjdk.java.net/projects/nashorn/[Nashorn]
+|https://mustache.github.io/[Mustache] |https://openjdk.java.net/projects/nashorn/[Nashorn]
+|https://react.dev/[React] |https://openjdk.java.net/projects/nashorn/[Nashorn]
+|https://ejs.co/[EJS] |https://openjdk.java.net/projects/nashorn/[Nashorn]
 |https://docs.ruby-lang.org/en/master/ERB.html[ERB] |https://www.jruby.org[JRuby]
 |https://docs.python.org/2/library/string.html#template-strings[String templates] |https://www.jython.org/[Jython]
+|https://github.com/sdeleuze/kotlin-script-templating[Kotlin Script templating] |{kotlin-site}[Kotlin]
 |===
 
 TIP: The basic rule for integrating any other script engine is that it must implement the
@@ -219,8 +228,17 @@ TIP: The basic rule for integrating any other script engine is that it must impl
 
 You need to have the script engine on your classpath, the details of which vary by script engine:
 
+* The https://openjdk.java.net/projects/nashorn/[Nashorn] JavaScript engine is provided with
+Java 8+. Using the latest update release available is highly recommended.
 * https://www.jruby.org[JRuby] should be added as a dependency for Ruby support.
 * https://www.jython.org[Jython] should be added as a dependency for Python support.
+* `org.jetbrains.kotlin:kotlin-script-util` dependency and a `META-INF/services/javax.script.ScriptEngineFactory`
+ file containing a `org.jetbrains.kotlin.script.jsr223.KotlinJsr223JvmLocalScriptEngineFactory`
+ line should be added for Kotlin script support. See
+ https://github.com/sdeleuze/kotlin-script-templating[this example] for more detail.
+
+You need to have the script templating library. One way to do that for JavaScript is
+through https://www.webjars.org/[WebJars].
 
 [[webflux-view-script-integrate]]
 === Script Templates
@@ -228,7 +246,7 @@ You need to have the script engine on your classpath, the details of which vary
 
 You can declare a `ScriptTemplateConfigurer` bean to specify the script engine to use,
 the script files to load, what function to call to render templates, and so on.
-The following example uses the Jython Python engine:
+The following example uses Mustache templates and the Nashorn JavaScript engine:
 
 [tabs]
 ======
@@ -237,7 +255,8 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
-	public class WebConfiguration implements WebFluxConfigurer {
+	@EnableWebFlux
+	public class WebConfig implements WebFluxConfigurer {
 
 		@Override
 		public void configureViewResolvers(ViewResolverRegistry registry) {
@@ -247,8 +266,9 @@ Java::
 		@Bean
 		public ScriptTemplateConfigurer configurer() {
 			ScriptTemplateConfigurer configurer = new ScriptTemplateConfigurer();
-			configurer.setEngineName("jython");
-			configurer.setScripts("render.py");
+			configurer.setEngineName("nashorn");
+			configurer.setScripts("mustache.js");
+			configurer.setRenderObject("Mustache");
 			configurer.setRenderFunction("render");
 			return configurer;
 		}
@@ -260,7 +280,8 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
-	class WebConfiguration : WebFluxConfigurer {
+	@EnableWebFlux
+	class WebConfig : WebFluxConfigurer {
 
 		override fun configureViewResolvers(registry: ViewResolverRegistry) {
 			registry.scriptTemplate()
@@ -268,8 +289,9 @@ Kotlin::
 
 		@Bean
 		fun configurer() = ScriptTemplateConfigurer().apply {
-			engineName = "jython"
-			setScripts("render.py")
+			engineName = "nashorn"
+			setScripts("mustache.js")
+			renderObject = "Mustache"
 			renderFunction = "render"
 		}
 	}
@@ -283,7 +305,94 @@ The `render` function is called with the following parameters:
 * `RenderingContext renderingContext`: The
   {spring-framework-api}/web/servlet/view/script/RenderingContext.html[`RenderingContext`]
   that gives access to the application context, the locale, the template loader, and the
-  URL
+  URL (since 5.0)
+
+`Mustache.render()` is natively compatible with this signature, so you can call it directly.
+
+If your templating technology requires some customization, you can provide a script that
+implements a custom render function. For example, https://handlebarsjs.com[Handlerbars]
+needs to compile templates before using them and requires a
+https://en.wikipedia.org/wiki/Polyfill[polyfill] in order to emulate some
+browser facilities not available in the server-side script engine.
+The following example shows how to set a custom render function:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebFlux
+	public class WebConfig implements WebFluxConfigurer {
+
+		@Override
+		public void configureViewResolvers(ViewResolverRegistry registry) {
+			registry.scriptTemplate();
+		}
+
+		@Bean
+		public ScriptTemplateConfigurer configurer() {
+			ScriptTemplateConfigurer configurer = new ScriptTemplateConfigurer();
+			configurer.setEngineName("nashorn");
+			configurer.setScripts("polyfill.js", "handlebars.js", "render.js");
+			configurer.setRenderFunction("render");
+			configurer.setSharedEngine(false);
+			return configurer;
+		}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebFlux
+	class WebConfig : WebFluxConfigurer {
+
+		override fun configureViewResolvers(registry: ViewResolverRegistry) {
+			registry.scriptTemplate()
+		}
+
+		@Bean
+		fun configurer() = ScriptTemplateConfigurer().apply {
+			engineName = "nashorn"
+			setScripts("polyfill.js", "handlebars.js", "render.js")
+			renderFunction = "render"
+			isSharedEngine = false
+		}
+	}
+----
+======
+
+NOTE: Setting the `sharedEngine` property to `false` is required when using non-thread-safe
+script engines with templating libraries not designed for concurrency, such as Handlebars or
+React running on Nashorn. In that case, Java SE 8 update 60 is required, due to
+https://bugs.openjdk.java.net/browse/JDK-8076099[this bug], but it is generally
+recommended to use a recent Java SE patch release in any case.
+
+`polyfill.js` defines only the `window` object needed by Handlebars to run properly,
+as the following snippet shows:
+
+[source,javascript,indent=0,subs="verbatim,quotes"]
+----
+	var window = {};
+----
+
+This basic `render.js` implementation compiles the template before using it. A production
+ready implementation should also store and reused cached templates or pre-compiled templates.
+This can be done on the script side, as well as any customization you need (managing
+template engine configuration for example).
+The following example shows how compile a template:
+
+[source,javascript,indent=0,subs="verbatim,quotes"]
+----
+	function render(template, model) {
+		var compiledTemplate = Handlebars.compile(template);
+		return compiledTemplate(model);
+	}
+----
 
 Check out the Spring Framework unit tests,
 {spring-framework-code}/spring-webflux/src/test/java/org/springframework/web/reactive/result/view/script[Java], and
@@ -373,7 +482,7 @@ purposes, it is useful to be able to alternate between rendering a model with an
 or as other formats (such as JSON or XML), depending on the content type requested by the client.
 To support doing so, Spring WebFlux provides the `HttpMessageWriterView`, which you can use to
 plug in any of the available xref:web/webflux/reactive-spring.adoc#webflux-codecs[Codecs] from
-`spring-web`, such as `JacksonJsonEncoder`, `JacksonSmileEncoder`, or `Jaxb2XmlEncoder`.
+`spring-web`, such as `Jackson2JsonEncoder`, `Jackson2SmileEncoder`, or `Jaxb2XmlEncoder`.
 
 Unlike other view technologies, `HttpMessageWriterView` does not require a `ViewResolver` but is
 instead xref:web/webflux/config.adoc#webflux-config-view-resolvers[configured] as a default view.

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

@@ -18,8 +18,8 @@ You can also use `WebClient.builder()` with further options:
 * `exchangeStrategies`: HTTP message reader/writer customizations.
 * `clientConnector`: HTTP client library settings.
 * `apiVersionInserter`: to insert API version values in the request
-* `observationRegistry`: the registry to use for enabling xref:integration/observability.adoc#observability.http-client.webclient[Observability support].
-* `observationConvention`: xref:integration/observability.adoc#observability.config[an optional, custom convention to extract metadata] for recorded observations.
+* `observationRegistry`: the registry to use for enabling xref:integration/observability.adoc#http-client.webclient[Observability support].
+* `observationConvention`: xref:integration/observability.adoc#config[an optional, custom convention to extract metadata] for recorded observations.
 
 For example:
 

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

@@ -66,13 +66,6 @@ from an existing `ProblemDetail`. This could be done centrally, for example, fro
 `@ControllerAdvice` such as `ResponseEntityExceptionHandler` that re-creates the
 `ProblemDetail` of an exception into a subclass with the additional non-standard fields.
 
-TIP: In Spring Boot, the `spring.webflux.problemdetails.enabled` property autoconfigures
-a `ResponseEntityExceptionHandler` that handles built-in exceptions with problem details.
-In that case, you may prefer to create another `@ControllerAdvice` instead of extending
-`ResponseEntityExceptionHandler` if you want to take over the handling of a specific
-built-in exception. You'll need to ensure your handler is ordered ahead of the one
-configured by Spring Boot whose order is 0.
-
 
 [[webflux-ann-rest-exceptions-i18n]]
 == Customization and i18n
@@ -142,10 +135,6 @@ Message codes and arguments for each error are also resolved via `MessageSource`
 | `+{0}+` the list of global errors, `+{1}+` the list of field errors.
 Message codes and arguments for each error are also resolved via `MessageSource`.
 
-| `NoResourceFoundException`
-| (default)
-| `+{0}+` the request path (or portion of) used to find a resource
-
 |===
 
 NOTE: Unlike other exceptions, the message arguments for

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

@@ -334,8 +334,19 @@ Kotlin::
 `ServerCodecConfigurer` provides a set of default readers and writers. You can use it to add
 more readers and writers, customize the default ones, or replace the default ones completely.
 
-For Jackson, consider using a Jackson format-specific builder like `JsonMapper.Builder` to configure Jackson's default
-properties.
+For Jackson JSON and XML, consider using
+{spring-framework-api}/http/converter/json/Jackson2ObjectMapperBuilder.html[`Jackson2ObjectMapperBuilder`],
+which customizes Jackson's default properties with the following ones:
+
+* {jackson-docs}/jackson-databind/javadoc/2.6/com/fasterxml/jackson/databind/DeserializationFeature.html#FAIL_ON_UNKNOWN_PROPERTIES[`DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES`] is disabled.
+* {jackson-docs}/jackson-databind/javadoc/2.6/com/fasterxml/jackson/databind/MapperFeature.html#DEFAULT_VIEW_INCLUSION[`MapperFeature.DEFAULT_VIEW_INCLUSION`] is disabled.
+
+It also automatically registers the following well-known modules if they are detected on the classpath:
+
+* {jackson-github-org}/jackson-datatype-jsr310[`jackson-datatype-jsr310`]: Support for Java 8 Date and Time API types.
+* {jackson-github-org}/jackson-datatype-jdk8[`jackson-datatype-jdk8`]: Support for other Java 8 types, such as `Optional`.
+* {jackson-github-org}/jackson-module-kotlin[`jackson-module-kotlin`]: Support for Kotlin classes and data classes.
+
 
 [[webflux-config-view-resolvers]]
 == View Resolvers
@@ -478,7 +489,7 @@ Java::
 		public void configureViewResolvers(ViewResolverRegistry registry) {
 			registry.freeMarker();
 
-			JacksonJsonEncoder encoder = new JacksonJsonEncoder();
+			Jackson2JsonEncoder encoder = new Jackson2JsonEncoder();
 			registry.defaultViews(new HttpMessageWriterView(encoder));
 		}
 
@@ -497,7 +508,7 @@ Kotlin::
 		override fun configureViewResolvers(registry: ViewResolverRegistry) {
 			registry.freeMarker()
 
-			val encoder = JacksonJsonEncoder()
+			val encoder = Jackson2JsonEncoder()
 			registry.defaultViews(HttpMessageWriterView(encoder))
 		}
 
@@ -690,7 +701,7 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim"]
 ----
 	@Configuration
-	class WebConfiguration : WebFluxConfigurer {
+	class WebConfiguration : WebMvcConfigurer {
 
 		override fun configureApiVersioning(configurer: ApiVersionConfigurer) {
 			configurer.useRequestHeader("API-Version")

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

@@ -5,7 +5,7 @@
 
 The following table shows the supported controller method arguments.
 
-Reactive types (Reactor, RxJava, xref:web/webflux-reactive-libraries.adoc[or other]) are
+Reactive types (Reactor, RxJava, xref:web-reactive.adoc#webflux-reactive-libraries[or other]) are
 supported on arguments that require blocking I/O (for example, reading the request body) to
 be resolved. This is marked in the Description column. Reactive types are not expected
 on arguments that do not require blocking.
@@ -114,6 +114,6 @@ and others) and is equivalent to `required=false`.
 | Any other argument
 | If a method argument is not matched to any of the above, it is, by default, resolved as
   a `@RequestParam` if it is a simple type, as determined by
-  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty],
+  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty],
   or as a `@ModelAttribute`, otherwise.
 |===

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

@@ -205,7 +205,7 @@ 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
-{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty]
+{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty]
 _AND_ that is not resolved by any other argument resolver is treated as an implicit `@ModelAttribute`.
 
 WARNING: When compiling to a native image with GraalVM, the implicit `@ModelAttribute`

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

@@ -41,8 +41,8 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	class MyForm(
-			private val name: String,
-			private val file: FilePart)
+			val name: String,
+			val file: FilePart)
 
 	@Controller
 	class FileUploadController {
@@ -103,8 +103,8 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@PostMapping("/")
-	fun handle(@RequestPart("meta-data") metadata: Part, // <1>
-			@RequestPart("file-data") file: FilePart): String { // <2>
+	fun handle(@RequestPart("meta-data") Part metadata, // <1>
+			@RequestPart("file-data") FilePart file): String { // <2>
 		// ...
 	}
 ----
@@ -169,8 +169,8 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@PostMapping("/")
-	fun handle(@Valid @RequestPart("meta-data") metadata: Mono<MetaData>): String {
-		// use one of the onError* operators...
+	fun handle(@Valid @RequestPart("meta-data") metadata: MetaData): String {
+		// ...
 	}
 ----
 ======
@@ -202,7 +202,7 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@PostMapping("/")
-	fun handle(@RequestBody parts: Mono<MultiValueMap<String, Part>>): String { // <1>
+	fun handle(@RequestBody parts: MultiValueMap<String, Part>): String { // <1>
 		// ...
 	}
 ----
@@ -227,7 +227,87 @@ when uploading. If the file is large enough to be split across multiple buffers,
 
 For example:
 
-include-code::./PartEventController[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+  @PostMapping("/")
+  public void handle(@RequestBody Flux<PartEvent> allPartsEvents) { <1>
+      allPartsEvents.windowUntil(PartEvent::isLast) <2>
+              .concatMap(p -> p.switchOnFirst((signal, partEvents) -> { <3>
+                  if (signal.hasValue()) {
+                      PartEvent event = signal.get();
+                      if (event instanceof FormPartEvent formEvent) { <4>
+                          String value = formEvent.value();
+                          // handle form field
+                      }
+                      else if (event instanceof FilePartEvent fileEvent) { <5>
+                          String filename = fileEvent.filename();
+                          Flux<DataBuffer> contents = partEvents.map(PartEvent::content); <6>
+                          // handle file upload
+                      }
+                      else {
+                          return Mono.error(new RuntimeException("Unexpected event: " + event));
+                      }
+                  }
+                  else {
+                      return partEvents; // either complete or error signal
+                  }
+              }));
+  }
+----
+<1> Using `@RequestBody`.
+<2> The final `PartEvent` for a particular part will have `isLast()` set to `true`, and can be
+followed by additional events belonging to subsequent parts.
+This makes the `isLast` property suitable as a predicate for the `Flux::windowUntil` operator, to
+split events from all parts into windows that each belong to a single part.
+<3> The `Flux::switchOnFirst` operator allows you to see whether you are handling a form field or
+file upload.
+<4> Handling the form field.
+<5> Handling the file upload.
+<6> The body contents must be completely consumed, relayed, or released to avoid memory leaks.
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@PostMapping("/")
+	fun handle(@RequestBody allPartsEvents: Flux<PartEvent>) = { // <1>
+      allPartsEvents.windowUntil(PartEvent::isLast) <2>
+          .concatMap {
+              it.switchOnFirst { signal, partEvents -> <3>
+                  if (signal.hasValue()) {
+                      val event = signal.get()
+                      if (event is FormPartEvent) { <4>
+                          val value: String = event.value();
+                          // handle form field
+                      } else if (event is FilePartEvent) { <5>
+                          val filename: String = event.filename();
+                          val contents: Flux<DataBuffer> = partEvents.map(PartEvent::content); <6>
+                          // handle file upload
+                      } else {
+                          return Mono.error(RuntimeException("Unexpected event: " + event));
+                      }
+                  } else {
+                      return partEvents; // either complete or error signal
+                  }
+              }
+          }
+}
+----
+<1> Using `@RequestBody`.
+<2> The final `PartEvent` for a particular part will have `isLast()` set to `true`, and can be
+followed by additional events belonging to subsequent parts.
+This makes the `isLast` property suitable as a predicate for the `Flux::windowUntil` operator, to
+split events from all parts into windows that each belong to a single part.
+<3> The `Flux::switchOnFirst` operator allows you to see whether you are handling a form field or
+file upload.
+<4> Handling the form field.
+<5> Handling the file upload.
+<6> The body contents must be completely consumed, relayed, or released to avoid memory leaks.
+======
 
 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/requestparam.adoc

@@ -74,6 +74,6 @@ When a `@RequestParam` annotation is declared on a `Map<String, String>` or
 
 Note that use of `@RequestParam` is optional -- for example, to set its attributes. By
 default, any argument that is a simple value type (as determined by
-{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty])
+{spring-framework-api}/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 `@RequestParam`.

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

@@ -33,7 +33,7 @@ Kotlin::
 ----
 ======
 
-WebFlux supports using a single value xref:web/webflux-reactive-libraries.adoc[reactive type] to
+WebFlux supports using a single value xref:web-reactive.adoc#webflux-reactive-libraries[reactive type] to
 produce the `ResponseEntity` asynchronously, and/or single and multi-value reactive types
 for the body. This allows a variety of async responses with `ResponseEntity` as follows:
 

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

@@ -87,6 +87,6 @@ Reactor provides a dedicated operator for that, `Flux#collectList()`.
 | Other return values
 | If a return value remains unresolved in any other way, it is treated as a model
   attribute, unless it is a simple type as determined by
-  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty],
+  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty],
   in which case it remains unresolved.
 |===

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

@@ -89,7 +89,60 @@ Kotlin::
 
 You can map requests by using glob patterns and wildcards:
 
-include::partial$web/uri-patterns.adoc[leveloffset=+1]
+[cols="2,3,5"]
+|===
+|Pattern |Description |Example
+
+| `spring`
+| Literal pattern
+| `+"/spring"+` matches `+"/spring"+`
+
+| `+?+`
+| Matches one character
+| `+"/pages/t?st.html"+` matches `+"/pages/test.html"+` and `+"/pages/t3st.html"+`
+
+| `+*+`
+| Matches zero or more characters within a path segment
+| `+"/resources/*.png"+` matches `+"/resources/file.png"+`
+
+`+"/projects/*/versions"+` matches `+"/projects/spring/versions"+` but does not match `+"/projects/spring/boot/versions"+`
+
+| `+**+`
+| Matches zero or more path segments
+| `+"/resources/**"+` matches `+"/resources/file.png"+` and `+"/resources/images/file.png"+`
+
+`+"/**/resources"+` matches `+"/spring/resources"+` and `+"/spring/framework/resources"+`
+
+`+"/resources/**/file.png"+` is invalid as `+**+` is not allowed in the middle of the path.
+
+`+"/**/{name}/resources"+` is invalid as only a literal pattern is allowed right after `+**+`.
+`+"/**/project/{project}/resources"+` is allowed.
+
+`+"/**/spring/**"+` is not allowed, as only a single `+**+`/`+{*path}+` instance is allowed per pattern.
+
+| `+{name}+`
+| Matches a path segment and captures it as a variable named "name"
+| `+"/projects/{project}/versions"+` matches `+"/projects/spring/versions"+` and captures `+project=spring+`
+`+"/projects/{project}/versions"+` does not match `+"/projects/spring/framework/versions"+` as it captures a single path segment.
+
+| `{name:[a-z]+}`
+| Matches the regexp `[a-z]+` as a path variable named "name"
+| `/projects/{project:[a-z]+}/versions` matches `/projects/spring/versions` but not `/projects/spring1/versions`
+
+| `+{*path}+`
+| Matches zero or more path segments and captures it as a variable named "path"
+| `+"/resources/{*file}"+` matches `+"/resources/images/file.png"+` and captures `+file=/images/file.png+`
+
+`+"{*path}/resources"+` matches `+"/spring/framework/resources"+` and captures `+path=/spring/framework+`
+
+`+"/resources/{*path}/file.png"+` is invalid as `{*path}` is not allowed in the middle of the path.
+
+`+"/{*path}/{name}/resources"+` is invalid as only a literal pattern is allowed right after `{*path}`.
+`+"/{*path}/project/{project}/resources"+` is allowed.
+
+`+"/{*path}/spring/**"+` is not allowed, as only a single `+**+`/`+{*path}+` instance is allowed per pattern.
+
+|===
 
 Captured URI variables can be accessed with `@PathVariable`, as the following example shows:
 
@@ -393,9 +446,9 @@ is used to map requests.
 Once API versioning is enabled, you can begin to map requests with versions.
 The `@RequestMapping` `version` attribute supports the following:
 
+- No value -- matches any version
 - Fixed version ("1.2") -- matches the given version only
 - Baseline version ("1.2+") -- matches the given version and above
-- No value -- matches any version, but is superseded by a more specific version match
 
 If multiple controller methods have a version less than or equal to the request version,
 the highest of those, and closest to the request version, is the one considered,
@@ -454,11 +507,6 @@ A request with version `"1.6"` does not have a match. (1) and (3) do match, but
 superseded by (4), which allows only a strict match, and therefore does not match.
 In this scenario, a `NotAcceptableApiVersionException` results in a 400 response.
 
-Controller methods without a version are intended to support clients created before a
-versioned alternative was introduced. Therefore, even though an unversioned controller
-method is considered a match for any version, it is in fact given the lowest priority,
-and is effectively superseded by any alternative controller method with a version.
-
 NOTE: The above assumes the request version is a
 xref:web/webflux/config.adoc#webflux-config-api-version["supported" version],
 or otherwise it would fail.

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

@@ -7,23 +7,19 @@ Spring WebFlux has built-in xref:core/validation/validator.adoc[Validation] for
 `@RequestMapping` methods, including xref:core/validation/beanvalidation.adoc[Java Bean Validation].
 Validation may be applied at one of two levels:
 
-1. Java Bean Validation is applied individually to an
-xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
+1. 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] method parameter
-annotated with `@jakarta.validation.Valid` or Spring's `@Validated` so long as
-it is a command object rather than a container such as `Map` or `Collection`, it does not
-have `Errors` or `BindingResult` immediately after in the method signature, and does not
-otherwise require method validation (see next). `WebExchangeBindException` is the
-exception raised when validating a method parameter individually.
+xref:web/webflux/controller/ann-methods/multipart-forms.adoc[@RequestPart] argument
+resolvers validate a method argument individually if the method parameter is annotated
+with Jakarta `@Valid` or Spring's `@Validated`, _AND_ there is no `Errors` or
+`BindingResult` parameter immediately after, _AND_ method validation is not needed (to be
+discussed next). The exception raised in this case is `WebExchangeBindException`.
 
-2. Java Bean Validation is applied to the method when `@Constraint` annotations such as
-`@Min`, `@NotBlank` and others are declared directly on method parameters, or on the
-method for the return value, and it supersedes any validation that would be applied
-otherwise to a method parameter individually because method validation covers both
-method parameter constraints and nested constraints via `@Valid`.
-`HandlerMethodValidationException` is the exception raised validation is applied
-to the method.
+2. When `@Constraint` annotations such as `@Min`, `@NotBlank` and others are declared
+directly on method parameters, or on the method (for the return value), then method
+validation must be applied, and that supersedes validation at the method argument level
+because method validation covers both method parameter constraints and nested constraints
+via `@Valid`. The exception raised in this case is `HandlerMethodValidationException`.
 
 Applications must handle both `WebExchangeBindException` and
 `HandlerMethodValidationException` as either may be raised depending on the controller

framework-docs/modules/ROOT/pages/web/webflux/dispatcher-handler.adoc

@@ -207,7 +207,7 @@ was not provided (for example, model attribute was returned) or an async return
 view resolution scenarios. Explore the options in your IDE with code completion.
 * `Model`, `Map`: Extra model attributes to be added to the model for the request.
 * Any other: Any other return value (except for simple types, as determined by
-{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty])
+{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty])
 is treated as a model attribute to be added to the model. The attribute name is derived
 from the class name by using {spring-framework-api}/core/Conventions.html[conventions],
 unless a handler method `@ModelAttribute` annotation is present.

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

@@ -77,7 +77,7 @@ as input, adapts it to a Reactor type internally, uses that, and returns either
 `Flux` or a `Mono` as output. So, you can pass any `Publisher` as input and you can apply
 operations on the output, but you need to adapt the output for use with another reactive library.
 Whenever feasible (for example, annotated controllers), WebFlux adapts transparently to the use
-of RxJava or another reactive library. See xref:web/webflux-reactive-libraries.adoc[Reactive Libraries] for more details.
+of RxJava or another reactive library. See xref:web-reactive.adoc#webflux-reactive-libraries[Reactive Libraries] for more details.
 
 NOTE: In addition to Reactive APIs, WebFlux can also be used with
 xref:languages/kotlin/coroutines.adoc[Coroutines] APIs in Kotlin which provides a more imperative style of programming.
@@ -148,7 +148,7 @@ RxJava to perform blocking calls on a separate thread but you would not be makin
 most of a non-blocking web stack.
 
 * If you have a Spring MVC application with calls to remote services, try the reactive `WebClient`.
-You can return reactive types (Reactor, RxJava, xref:web/webflux-reactive-libraries.adoc[or other])
+You can return reactive types (Reactor, RxJava, xref:web-reactive.adoc#webflux-reactive-libraries[or other])
 directly from Spring MVC controller methods. The greater the latency per call or the
 interdependency among calls, the more dramatic the benefits. Spring MVC controllers
 can call other reactive components too.

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

@@ -459,22 +459,22 @@ xref:web/webflux/config.adoc#webflux-config-message-codecs[HTTP message codecs].
 JSON and binary JSON ({jackson-github-org}/smile-format-specification[Smile]) are
 both supported when the Jackson library is present.
 
-The `JacksonJsonDecoder` works as follows:
+The `Jackson2Decoder` works as follows:
 
 * Jackson's asynchronous, non-blocking parser is used to aggregate a stream of byte chunks
 into ``TokenBuffer``'s each representing a JSON object.
-* Each `TokenBuffer` is passed to Jackson's `JsonMapper` to create a higher level object.
+* Each `TokenBuffer` is passed to Jackson's `ObjectMapper` to create a higher level object.
 * When decoding to a single-value publisher (for example, `Mono`), there is one `TokenBuffer`.
 * When decoding to a multi-value publisher (for example, `Flux`), each `TokenBuffer` is passed to
-the `JsonMapper` as soon as enough bytes are received for a fully formed object. The
+the `ObjectMapper` as soon as enough bytes are received for a fully formed object. The
 input content can be a JSON array, or any
 https://en.wikipedia.org/wiki/JSON_streaming[line-delimited JSON] format such as NDJSON,
 JSON Lines, or JSON Text Sequences.
 
-The `JacksonJsonEncoder` works as follows:
+The `Jackson2Encoder` works as follows:
 
 * For a single value publisher (for example, `Mono`), simply serialize it through the
-`JsonMapper`.
+`ObjectMapper`.
 * For a multi-value publisher with `application/json`, by default collect the values with
 `Flux#collectToList()` and then serialize the resulting collection.
 * For a multi-value publisher with a streaming media type such as
@@ -482,12 +482,12 @@ The `JacksonJsonEncoder` works as follows:
 flush each value individually using a
 https://en.wikipedia.org/wiki/JSON_streaming[line-delimited JSON] format. Other
 streaming media types may be registered with the encoder.
-* For SSE the `JacksonJsonEncoder` is invoked per event and the output is flushed to ensure
+* For SSE the `Jackson2Encoder` is invoked per event and the output is flushed to ensure
 delivery without delay.
 
 [NOTE]
 ====
-By default both `JacksonJsonEncoder` and `JacksonJsonDecoder` do not support elements of type
+By default both `Jackson2Encoder` and `Jackson2Decoder` do not support elements of type
 `String`. Instead the default assumption is that a string or a sequence of strings
 represent serialized JSON content, to be rendered by the `CharSequenceEncoder`. If what
 you need is to render a JSON array from `Flux<String>`, use `Flux#collectToList()` and
@@ -658,6 +658,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
+	@EnableWebFlux
 	class MyConfig implements WebFluxConfigurer {
 
 		@Override
@@ -672,6 +673,7 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
 	@Configuration
+	@EnableWebFlux
 	class MyConfig : WebFluxConfigurer {
 
 		override fun configureHttpMessageCodecs(configurer: ServerCodecConfigurer) {

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

@@ -71,7 +71,7 @@ rejected. No CORS headers are added to the responses of simple and actual CORS r
 and, consequently, browsers reject them.
 
 Each `HandlerMapping` can be
-{spring-framework-api}/web/servlet/handler/AbstractHandlerMapping.html#setCorsConfigurations(java.util.Map)[configured]
+{spring-framework-api}/web/servlet/handler/AbstractHandlerMapping.html#setCorsConfigurations-java.util.Map-[configured]
 individually with URL pattern-based `CorsConfiguration` mappings. In most cases, applications
 use the MVC Java configuration or the XML namespace to declare such mappings, which results
 in a single global map being passed to all `HandlerMapping` instances.
@@ -84,7 +84,7 @@ class- or method-level `@CrossOrigin` annotations (other handlers can implement
 The rules for combining global and local configuration are generally additive -- for example,
 all global and all local origins. For those attributes where only a single value can be
 accepted, for example, `allowCredentials` and `maxAge`, the local overrides the global value. See
-{spring-framework-api}/web/cors/CorsConfiguration.html#combine(org.springframework.web.cors.CorsConfiguration)[`CorsConfiguration#combine(CorsConfiguration)`]
+{spring-framework-api}/web/cors/CorsConfiguration.html#combine-org.springframework.web.cors.CorsConfiguration-[`CorsConfiguration#combine(CorsConfiguration)`]
 for more details.
 
 [TIP]
@@ -208,7 +208,6 @@ Kotlin::
 		fun remove(@PathVariable id: Long) {
 			// ...
 		}
-	}
 ----
 ======
 
@@ -287,9 +286,84 @@ the `allowOriginPatterns` property may be used to match to a dynamic set of orig
 
 `maxAge` is set to 30 minutes.
 
-You can enable CORS in the Spring MVC configuration as the following example shows:
+[[mvc-cors-global-java]]
+=== Java Configuration
+[.small]#xref:web/webflux-cors.adoc#webflux-cors-global[See equivalent in the Reactive stack]#
+
+To enable CORS in the MVC Java config, you can use the `CorsRegistry` callback,
+as the following example shows:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebMvc
+	public class WebConfig implements WebMvcConfigurer {
+
+		@Override
+		public void addCorsMappings(CorsRegistry registry) {
+
+			registry.addMapping("/api/**")
+				.allowedOrigins("https://domain2.com")
+				.allowedMethods("PUT", "DELETE")
+				.allowedHeaders("header1", "header2", "header3")
+				.exposedHeaders("header1", "header2")
+				.allowCredentials(true).maxAge(3600);
+
+			// Add more mappings...
+		}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebMvc
+	class WebConfig : WebMvcConfigurer {
+
+		override fun addCorsMappings(registry: CorsRegistry) {
+
+			registry.addMapping("/api/**")
+					.allowedOrigins("https://domain2.com")
+					.allowedMethods("PUT", "DELETE")
+					.allowedHeaders("header1", "header2", "header3")
+					.exposedHeaders("header1", "header2")
+					.allowCredentials(true).maxAge(3600)
+
+			// Add more mappings...
+		}
+	}
+----
+======
+
+[[mvc-cors-global-xml]]
+=== XML Configuration
+
+To enable CORS in the XML namespace, you can use the `<mvc:cors>` element,
+as the following example shows:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+<mvc:cors>
+
+	<mvc:mapping path="/api/**"
+		allowed-origins="https://domain1.com, https://domain2.com"
+		allowed-methods="GET, PUT"
+		allowed-headers="header1, header2, header3"
+		exposed-headers="header1, header2" allow-credentials="true"
+		max-age="123" />
+
+	<mvc:mapping path="/resources/**"
+		allowed-origins="https://domain1.com" />
+
+</mvc:cors>
+----
 
-include-code::./WebConfiguration[tag=snippet,indent=0]
 
 [[mvc-cors-filter]]
 == CORS Filter

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

@@ -184,8 +184,7 @@ val map = request.params()
 ----
 ======
 
-The following shows how to bind request parameters, URI variables, or headers via `DataBinder`,
-and also shows how to customize the `DataBinder`:
+The following shows how to bind request parameters, including an optional `DataBinder` customization:
 
 [tabs]
 ======
@@ -900,9 +899,81 @@ processing lifecycle and also (potentially) run side by side with annotated cont
 any are declared. It is also how functional endpoints are enabled by the Spring Boot Web
 starter.
 
-The following example shows a related Spring MVC configuration:
+The following example shows a WebMvc Java configuration:
 
-include-code::./WebConfiguration[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableMvc
+	public class WebConfig implements WebMvcConfigurer {
+
+		@Bean
+		public RouterFunction<?> routerFunctionA() {
+			// ...
+		}
+
+		@Bean
+		public RouterFunction<?> routerFunctionB() {
+			// ...
+		}
+
+		// ...
+
+		@Override
+		public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
+			// configure message conversion...
+		}
+
+		@Override
+		public void addCorsMappings(CorsRegistry registry) {
+			// configure CORS...
+		}
+
+		@Override
+		public void configureViewResolvers(ViewResolverRegistry registry) {
+			// configure view resolution for HTML rendering...
+		}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableMvc
+	class WebConfig : WebMvcConfigurer {
+
+		@Bean
+		fun routerFunctionA(): RouterFunction<*> {
+			// ...
+		}
+
+		@Bean
+		fun routerFunctionB(): RouterFunction<*> {
+			// ...
+		}
+
+		// ...
+
+		override fun configureMessageConverters(converters: List<HttpMessageConverter<*>>) {
+			// configure message conversion...
+		}
+
+		override fun addCorsMappings(registry: CorsRegistry) {
+			// configure CORS...
+		}
+
+		override fun configureViewResolvers(registry: ViewResolverRegistry) {
+			// configure view resolution for HTML rendering...
+		}
+	}
+----
+======
 
 
 [[webmvc-fn-handler-filter-function]]

framework-docs/modules/ROOT/pages/web/webmvc-view/mvc-freemarker.adoc

@@ -14,7 +14,82 @@ integration for using Spring MVC with FreeMarker templates.
 
 The following example shows how to configure FreeMarker as a view technology:
 
-include-code::./WebConfiguration[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+		@Configuration
+		@EnableWebMvc
+		public class WebConfig implements WebMvcConfigurer {
+
+			@Override
+			public void configureViewResolvers(ViewResolverRegistry registry) {
+				registry.freeMarker();
+			}
+
+			// Configure FreeMarker...
+
+			@Bean
+			public FreeMarkerConfigurer freeMarkerConfigurer() {
+				FreeMarkerConfigurer configurer = new FreeMarkerConfigurer();
+				configurer.setTemplateLoaderPath("/WEB-INF/freemarker");
+				configurer.setDefaultCharset(StandardCharsets.UTF_8);
+				return configurer;
+			}
+		}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebMvc
+	class WebConfig : WebMvcConfigurer {
+
+		override fun configureViewResolvers(registry: ViewResolverRegistry) {
+			registry.freeMarker()
+		}
+
+		// Configure FreeMarker...
+
+		@Bean
+		fun freeMarkerConfigurer() = FreeMarkerConfigurer().apply {
+			setTemplateLoaderPath("/WEB-INF/freemarker")
+			setDefaultCharset(StandardCharsets.UTF_8)
+		}
+	}
+----
+======
+
+The following example shows how to configure the same in XML:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<mvc:annotation-driven/>
+
+	<mvc:view-resolvers>
+		<mvc:freemarker/>
+	</mvc:view-resolvers>
+
+	<!-- Configure FreeMarker... -->
+	<mvc:freemarker-configurer>
+		<mvc:template-loader-path location="/WEB-INF/freemarker"/>
+	</mvc:freemarker-configurer>
+----
+
+Alternatively, you can also declare the `FreeMarkerConfigurer` bean for full control over all
+properties, as the following example shows:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
+		<property name="templateLoaderPath" value="/WEB-INF/freemarker/"/>
+		<property name="defaultEncoding" value="UTF-8"/>
+	</bean>
+----
 
 Your templates need to be stored in the directory specified by the `FreeMarkerConfigurer`
 shown in the preceding example. Given the preceding configuration, if your controller
@@ -32,7 +107,19 @@ properties on the `FreeMarkerConfigurer` bean. The `freemarkerSettings` property
 a `java.util.Properties` object, and the `freemarkerVariables` property requires a
 `java.util.Map`. The following example shows how to use a `FreeMarkerConfigurer`:
 
-include-code::./WebConfiguration[tag=snippet,indent=0]
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
+		<property name="templateLoaderPath" value="/WEB-INF/freemarker/"/>
+		<property name="freemarkerVariables">
+			<map>
+				<entry key="xml_escape" value-ref="fmXmlEscape"/>
+			</map>
+		</property>
+	</bean>
+
+	<bean id="fmXmlEscape" class="freemarker.template.utility.XmlEscape"/>
+----
 
 See the FreeMarker documentation for details of settings and variables as they apply to
 the `Configuration` object.

framework-docs/modules/ROOT/pages/web/webmvc-view/mvc-groovymarkup.adoc

@@ -14,7 +14,68 @@ NOTE: The Groovy Markup Template engine requires Groovy 2.3.1+.
 
 The following example shows how to configure the Groovy Markup Template Engine:
 
-include-code::./WebConfiguration[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebMvc
+	public class WebConfig implements WebMvcConfigurer {
+
+		@Override
+		public void configureViewResolvers(ViewResolverRegistry registry) {
+			registry.groovy();
+		}
+
+		// Configure the Groovy Markup Template Engine...
+
+		@Bean
+		public GroovyMarkupConfigurer groovyMarkupConfigurer() {
+			GroovyMarkupConfigurer configurer = new GroovyMarkupConfigurer();
+			configurer.setResourceLoaderPath("/WEB-INF/");
+			return configurer;
+		}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebMvc
+	class WebConfig : WebMvcConfigurer {
+
+		override fun configureViewResolvers(registry: ViewResolverRegistry) {
+			registry.groovy()
+		}
+
+		// Configure the Groovy Markup Template Engine...
+
+		@Bean
+		fun groovyMarkupConfigurer() = GroovyMarkupConfigurer().apply {
+			resourceLoaderPath = "/WEB-INF/"
+		}
+	}
+----
+======
+
+The following example shows how to configure the same in XML:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<mvc:annotation-driven/>
+
+	<mvc:view-resolvers>
+		<mvc:groovy/>
+	</mvc:view-resolvers>
+
+	<!-- Configure the Groovy Markup Template Engine... -->
+	<mvc:groovy-configurer resource-loader-path="/WEB-INF/"/>
+----
+
 
 [[mvc-view-groovymarkup-example]]
 == Example

framework-docs/modules/ROOT/pages/web/webmvc-view/mvc-jackson.adoc

@@ -10,7 +10,7 @@ Spring offers support for the Jackson JSON library.
 == Jackson-based JSON MVC Views
 [.small]#xref:web/webflux-view.adoc#webflux-view-httpmessagewriter[See equivalent in the Reactive stack]#
 
-The `JacksonJsonView` uses the Jackson library's `JsonMapper` to render the response
+The `MappingJackson2JsonView` uses the Jackson library's `ObjectMapper` to render the response
 content as JSON. By default, the entire contents of the model map (with the exception of
 framework-specific classes) are encoded as JSON. For cases where the contents of the
 map need to be filtered, you can specify a specific set of model attributes to encode
@@ -18,17 +18,17 @@ by using the `modelKeys` property. You can also use the `extractValueFromSingleK
 property to have the value in single-key models extracted and serialized directly rather
 than as a map of model attributes.
 
-You can customize JSON mapping as needed by using Jackson's provided annotations. When
-you need further control, you can inject a custom `JsonMapper` through the `JsonMapper`
-or `JsonMapper.Builder` constructor parameters, for cases where you need to provide
-custom JSON serializers and deserializers for specific types.
+You can customize JSON mapping as needed by using Jackson's provided
+annotations. When you need further control, you can inject a custom `ObjectMapper`
+through the `ObjectMapper` property, for cases where you need to provide custom JSON
+serializers and deserializers for specific types.
 
 
 [[mvc-view-xml-mapping]]
 == Jackson-based XML Views
 [.small]#xref:web/webflux-view.adoc#webflux-view-httpmessagewriter[See equivalent in the Reactive stack]#
 
-`JacksonXmlView` uses the
+`MappingJackson2XmlView` uses the
 {jackson-github-org}/jackson-dataformat-xml[Jackson XML extension's] `XmlMapper`
 to render the response content as XML. If the model contains multiple entries, you should
 explicitly set the object to be serialized by using the `modelKey` bean property. If the
@@ -36,5 +36,5 @@ model contains a single entry, it is serialized automatically.
 
 You can customize XML mapping as needed by using JAXB or Jackson's provided
 annotations. When you need further control, you can inject a custom `XmlMapper`
-created via `XmlMapper.Builder` for cases where custom XML you need to provide
-serializers and deserializers for specific types.
+through the `ObjectMapper` property, for cases where custom XML
+you need to provide serializers and deserializers for specific types.

framework-docs/modules/ROOT/pages/web/webmvc-view/mvc-jsp.adoc

@@ -16,11 +16,39 @@ a directory under the `WEB-INF` directory so there can be no direct access by cl
 This is what is done by the configuration below which registers a JSP view resolver using
 a default view name prefix of `"/WEB-INF/"` and a default suffix of `".jsp"`.
 
-include-code::./WebConfiguration[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+@EnableWebMvc
+@Configuration
+public class WebConfig implements WebMvcConfigurer {
+
+    @Override
+    public void configureViewResolvers(ViewResolverRegistry registry) {
+        registry.jsp();
+    }
+}
+----
+
+XML::
++
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+    <mvc:annotation-driven/>
+
+    <mvc:view-resolvers>
+        <mvc:jsp/>
+    </mvc:view-resolvers>
+----
+======
 
 [NOTE]
 You can specify custom prefix and suffix.
 
+
 [[mvc-view-jsp-jstl]]
 == JSPs versus JSTL
 

framework-docs/modules/ROOT/pages/web/webmvc-view/mvc-script.adoc

@@ -11,8 +11,13 @@ templating libraries on different script engines:
 [%header]
 |===
 |Scripting Library |Scripting Engine
+|https://handlebarsjs.com/[Handlebars] |https://openjdk.java.net/projects/nashorn/[Nashorn]
+|https://mustache.github.io/[Mustache] |https://openjdk.java.net/projects/nashorn/[Nashorn]
+|https://react.dev/[React] |https://openjdk.java.net/projects/nashorn/[Nashorn]
+|https://ejs.co/[EJS] |https://openjdk.java.net/projects/nashorn/[Nashorn]
 |https://docs.ruby-lang.org/en/master/ERB.html[ERB] |https://www.jruby.org[JRuby]
 |https://docs.python.org/2/library/string.html#template-strings[String templates] |https://www.jython.org/[Jython]
+|https://github.com/sdeleuze/kotlin-script-templating[Kotlin Script templating] |{kotlin-site}[Kotlin]
 |===
 
 TIP: The basic rule for integrating any other script engine is that it must implement the
@@ -25,8 +30,18 @@ TIP: The basic rule for integrating any other script engine is that it must impl
 
 You need to have the script engine on your classpath, the details of which vary by script engine:
 
+* The https://openjdk.java.net/projects/nashorn/[Nashorn] JavaScript engine is provided with
+Java 8+. Using the latest update release available is highly recommended.
 * https://www.jruby.org[JRuby] should be added as a dependency for Ruby support.
 * https://www.jython.org[Jython] should be added as a dependency for Python support.
+* `org.jetbrains.kotlin:kotlin-script-util` dependency and a `META-INF/services/javax.script.ScriptEngineFactory`
+ file containing a `org.jetbrains.kotlin.script.jsr223.KotlinJsr223JvmLocalScriptEngineFactory`
+ line should be added for Kotlin script support. See
+ https://github.com/sdeleuze/kotlin-script-templating[this example] for more details.
+
+You need to have the script templating library. One way to do that for JavaScript is
+through https://www.webjars.org/[WebJars].
+
 
 [[mvc-view-script-integrate]]
 == Script Templates
@@ -34,20 +49,74 @@ You need to have the script engine on your classpath, the details of which vary
 
 You can declare a `ScriptTemplateConfigurer` bean to specify the script engine to use,
 the script files to load, what function to call to render templates, and so on.
-The following example uses the Jython Python engine:
+The following example uses Mustache templates and the Nashorn JavaScript engine:
 
-include-code::./WebConfiguration[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebMvc
+	public class WebConfig implements WebMvcConfigurer {
 
-The render function is called with the following parameters:
+		@Override
+		public void configureViewResolvers(ViewResolverRegistry registry) {
+			registry.scriptTemplate();
+		}
 
-* `String template`: The template content
-* `Map model`: The view model
-* `RenderingContext renderingContext`: The
-{spring-framework-api}/web/servlet/view/script/RenderingContext.html[`RenderingContext`]
-that gives access to the application context, the locale, the template loader, and the
-URL
+		@Bean
+		public ScriptTemplateConfigurer configurer() {
+			ScriptTemplateConfigurer configurer = new ScriptTemplateConfigurer();
+			configurer.setEngineName("nashorn");
+			configurer.setScripts("mustache.js");
+			configurer.setRenderObject("Mustache");
+			configurer.setRenderFunction("render");
+			return configurer;
+		}
+	}
+----
 
-The controller is used to populate the model attributes and specify the view name, as the following example shows:
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebMvc
+	class WebConfig : WebMvcConfigurer {
+
+		override fun configureViewResolvers(registry: ViewResolverRegistry) {
+			registry.scriptTemplate()
+		}
+
+		@Bean
+		fun configurer() = ScriptTemplateConfigurer().apply {
+			engineName = "nashorn"
+			setScripts("mustache.js")
+			renderObject = "Mustache"
+			renderFunction = "render"
+		}
+	}
+----
+======
+
+The following example shows the same arrangement in XML:
+
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<mvc:annotation-driven/>
+
+	<mvc:view-resolvers>
+		<mvc:script-template/>
+	</mvc:view-resolvers>
+
+	<mvc:script-template-configurer engine-name="nashorn" render-object="Mustache" render-function="render">
+		<mvc:script location="mustache.js"/>
+	</mvc:script-template-configurer>
+----
+
+The controller would look no different for the Java and XML configurations, as the following example shows:
 
 [tabs]
 ======
@@ -84,6 +153,115 @@ Kotlin::
 ----
 ======
 
+The following example shows the Mustache template:
+
+[source,html,indent=0,subs="verbatim,quotes"]
+----
+	<html>
+		<head>
+			<title>{{title}}</title>
+		</head>
+		<body>
+			<p>{{body}}</p>
+		</body>
+	</html>
+----
+
+The render function is called with the following parameters:
+
+* `String template`: The template content
+* `Map model`: The view model
+* `RenderingContext renderingContext`: The
+  {spring-framework-api}/web/servlet/view/script/RenderingContext.html[`RenderingContext`]
+  that gives access to the application context, the locale, the template loader, and the
+  URL (since 5.0)
+
+`Mustache.render()` is natively compatible with this signature, so you can call it directly.
+
+If your templating technology requires some customization, you can provide a script that
+implements a custom render function. For example, https://handlebarsjs.com[Handlerbars]
+needs to compile templates before using them and requires a
+https://en.wikipedia.org/wiki/Polyfill[polyfill] to emulate some
+browser facilities that are not available in the server-side script engine.
+
+The following example shows how to do so:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebMvc
+	public class WebConfig implements WebMvcConfigurer {
+
+		@Override
+		public void configureViewResolvers(ViewResolverRegistry registry) {
+			registry.scriptTemplate();
+		}
+
+		@Bean
+		public ScriptTemplateConfigurer configurer() {
+			ScriptTemplateConfigurer configurer = new ScriptTemplateConfigurer();
+			configurer.setEngineName("nashorn");
+			configurer.setScripts("polyfill.js", "handlebars.js", "render.js");
+			configurer.setRenderFunction("render");
+			configurer.setSharedEngine(false);
+			return configurer;
+		}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@Configuration
+	@EnableWebMvc
+	class WebConfig : WebMvcConfigurer {
+
+		override fun configureViewResolvers(registry: ViewResolverRegistry) {
+			registry.scriptTemplate()
+		}
+
+		@Bean
+		fun configurer() = ScriptTemplateConfigurer().apply {
+			engineName = "nashorn"
+			setScripts("polyfill.js", "handlebars.js", "render.js")
+			renderFunction = "render"
+			isSharedEngine = false	
+		}
+	}
+----
+======
+
+NOTE: Setting the `sharedEngine` property to `false` is required when using non-thread-safe
+script engines with templating libraries not designed for concurrency, such as Handlebars or
+React running on Nashorn. In that case, Java SE 8 update 60 is required, due to
+https://bugs.openjdk.java.net/browse/JDK-8076099[this bug], but it is generally
+recommended to use a recent Java SE patch release in any case.
+
+`polyfill.js` defines only the `window` object needed by Handlebars to run properly, as follows:
+
+[source,javascript,indent=0,subs="verbatim,quotes"]
+----
+	var window = {};
+----
+
+This basic `render.js` implementation compiles the template before using it. A production-ready
+implementation should also store any reused cached templates or pre-compiled templates.
+You can do so on the script side (and handle any customization you need -- managing
+template engine configuration, for example). The following example shows how to do so:
+
+[source,javascript,indent=0,subs="verbatim,quotes"]
+----
+	function render(template, model) {
+		var compiledTemplate = Handlebars.compile(template);
+		return compiledTemplate(model);
+	}
+----
+
 Check out the Spring Framework unit tests,
 {spring-framework-code}/spring-webmvc/src/test/java/org/springframework/web/servlet/view/script[Java], and
 {spring-framework-code}/spring-webmvc/src/test/resources/org/springframework/web/servlet/view/script[resources],

framework-docs/modules/ROOT/pages/web/webmvc-view/mvc-xslt.adoc

@@ -21,7 +21,45 @@ Configuration is standard for a simple Spring web application: The MVC configura
 has to define an `XsltViewResolver` bean and regular MVC annotation configuration.
 The following example shows how to do so:
 
-include-code::./WebConfiguration[tag=snippet,indent=0]
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@EnableWebMvc
+	@ComponentScan
+	@Configuration
+	public class WebConfig implements WebMvcConfigurer {
+
+		@Bean
+		public XsltViewResolver xsltViewResolver() {
+			XsltViewResolver viewResolver = new XsltViewResolver();
+			viewResolver.setPrefix("/WEB-INF/xsl/");
+			viewResolver.setSuffix(".xslt");
+			return viewResolver;
+		}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes"]
+----
+	@EnableWebMvc
+	@ComponentScan
+	@Configuration
+	class WebConfig : WebMvcConfigurer {
+
+		@Bean
+		fun xsltViewResolver() = XsltViewResolver().apply {
+			setPrefix("/WEB-INF/xsl/")
+			setSuffix(".xslt")	
+		}
+	}
+----
+======
+
 
 [[mvc-view-xslt-controllercode]]
 == Controller

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

@@ -3,10 +3,7 @@
 
 [.small]#xref:web/webflux/reactive-spring.adoc#webflux-filters[See equivalent in the Reactive stack]#
 
-In the Servlet API, you can add a `jakarta.servlet.Filter` to apply interception-style logic
-before and after the rest of the processing chain of filters and the target `Servlet`.
-
-The `spring-web` module has a number of built-in `Filter` implementations:
+The `spring-web` module provides some useful filters:
 
 * xref:web/webmvc/filters.adoc#filters-http-put[Form Data]
 * xref:web/webmvc/filters.adoc#filters-forwarded-headers[Forwarded Headers]
@@ -14,19 +11,9 @@ The `spring-web` module has a number of built-in `Filter` implementations:
 * xref:web/webmvc/filters.adoc#filters-cors[CORS]
 * xref:web/webmvc/filters.adoc#filters.url-handler[URL Handler]
 
-There are also base class implementations for use in Spring applications:
-
-* `GenericFilterBean` -- base class for a `Filter` configured as a Spring bean;
-integrates with the Spring `ApplicationContext` lifecycle.
-* `OncePerRequestFilter` -- extension of `GenericFilterBean` that supports a single
-invocation at the start of a request, i.e. during the `REQUEST` dispatch phase, and
-ignoring further handling via `FORWARD` dispatches. The filter also provides control
-over whether the `Filter` gets involved in `ASYNC` and `ERROR` dispatches.
-
-Servlet filters can be configured in `web.xml` or via Servlet annotations.
-In a Spring Boot application , you can
-{spring-boot-docs}/how-to/webserver.html#howto.webserver.add-servlet-filter-listener.spring-bean[declare Filter's as beans]
-and Boot will have them configured.
+Servlet filters can be configured in the `web.xml` configuration file or using Servlet annotations.
+If you are using Spring Boot, you can
+{spring-boot-docs}/how-to/webserver.html#howto.webserver.add-servlet-filter-listener.spring-bean[declare them as beans and configure them as part of your application].
 
 
 [[filters-http-put]]

framework-docs/modules/ROOT/pages/web/webmvc/message-converters.adoc

@@ -42,25 +42,25 @@ This converter requires a `Marshaller` and `Unmarshaller` before it can be used.
 You can inject these through constructor or bean properties.
 By default, this converter supports `text/xml` and `application/xml`.
 
-| `JacksonJsonHttpMessageConverter`
-| An `HttpMessageConverter` implementation that can read and write JSON by using Jackson's `JsonMapper`.
+| `MappingJackson2HttpMessageConverter`
+| An `HttpMessageConverter` implementation that can read and write JSON by using Jackson's `ObjectMapper`.
 You can customize JSON mapping as needed through the use of Jackson's provided annotations.
-When you need further control (for cases where custom JSON serializers/deserializers need to be provided for specific types), you can inject a custom `JsonMapper` through the `JsonMapper` or `JsonMapper.Builder ` constructor parameters.
-By default, this converter supports `application/json`. This requires the `tools.jackson.core:jackson-databind` dependency.
+When you need further control (for cases where custom JSON serializers/deserializers need to be provided for specific types), you can inject a custom `ObjectMapper` through the `ObjectMapper` property.
+By default, this converter supports `application/json`. This requires the `com.fasterxml.jackson.core:jackson-databind` dependency.
 
-| `JacksonXmlHttpMessageConverter`
+| `MappingJackson2XmlHttpMessageConverter`
 | An `HttpMessageConverter` implementation that can read and write XML by using {jackson-github-org}/jackson-dataformat-xml[Jackson XML] extension's `XmlMapper`.
 You can customize XML mapping as needed through the use of JAXB or Jackson's provided annotations.
-When you need further control (for cases where custom XML serializers/deserializers need to be provided for specific types), you can inject a custom `XmlMapper` through the `JsonMapper` or `JsonMapper.Builder` constructor parameters.
-By default, this converter supports `application/xml`. This requires the `tools.jackson.dataformat:jackson-dataformat-xml` dependency.
+When you need further control (for cases where custom XML serializers/deserializers need to be provided for specific types), you can inject a custom `XmlMapper` through the `ObjectMapper` property.
+By default, this converter supports `application/xml`. This requires the `com.fasterxml.jackson.dataformat:jackson-dataformat-xml` dependency.
 
 | `KotlinSerializationJsonHttpMessageConverter`
 | An `HttpMessageConverter` implementation that can read and write JSON using `kotlinx.serialization`.
 This converter is not configured by default, as this conflicts with Jackson.
 Developers must configure it as an additional converter ahead of the Jackson one.
 
-| `JacksonCborHttpMessageConverter`
-| `tools.jackson.dataformat:jackson-dataformat-cbor`
+| `MappingJackson2CborHttpMessageConverter`
+| `com.fasterxml.jackson.dataformat:jackson-dataformat-cbor`
 
 | `SourceHttpMessageConverter`
 | An `HttpMessageConverter` implementation that can read and write `javax.xml.transform.Source` from the HTTP request and response.

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

@@ -414,7 +414,7 @@ customize the status and headers of the response.
 [.small]#xref:web/webflux/reactive-spring.adoc#webflux-codecs-streaming[See equivalent in the Reactive stack]#
 
 Spring MVC supports use of reactive client libraries in a controller (also read
-xref:web/webflux-reactive-libraries.adoc[Reactive Libraries] in the WebFlux section).
+xref:web-reactive.adoc#webflux-reactive-libraries[Reactive Libraries] in the WebFlux section).
 This includes the `WebClient` from `spring-webflux` and others, such as Spring Data
 reactive data repositories. In such scenarios, it is convenient to be able to return
 reactive types from the controller method.
@@ -422,7 +422,7 @@ reactive types from the controller method.
 Reactive return values are handled as follows:
 
 * A single-value promise is adapted to, similar to using `DeferredResult`. Examples
-include `CompletionStage` (JDK), `Mono` (Reactor), and `Single` (RxJava).
+include `CompletionStage` (JDK), Mono` (Reactor), and `Single` (RxJava).
 * A multi-value stream with a streaming media type (such as `application/x-ndjson`
 or `text/event-stream`) is adapted to, similar to using `ResponseBodyEmitter` or
 `SseEmitter`. Examples include `Flux` (Reactor) or `Observable` (RxJava).