Release v7.0.5

2026-06-08 17:33:33 +00:00 · 2026-02-18 13:31:03 +01:00
1668 changed files with 15897 additions and 30530 deletions
@@ -27,7 +27,7 @@ jobs:
            /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
            /**/framework-api-*-docs.zip::zip.type=docs
            /**/framework-api-*-schema.zip::zip.type=schema
-          build-name: 'spring-framework-7.1.x'
+          build-name: 'spring-framework-7.0.x'
          folder: 'deployment-repository'
          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
          repository: 'libs-snapshot-local'
@@ -2,8 +2,8 @@ name: Release Milestone
 on:
  push:
    tags:
-      - v7.1.0-M[1-9]
-      - v7.1.0-RC[1-9]
+      - v7.0.0-M[1-9]
+      - v7.0.0-RC[1-9]
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
 jobs:
@@ -2,7 +2,7 @@ name: Release
 on:
  push:
    tags:
-      - v7.1.[0-9]+
+      - v7.0.[0-9]+
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
 jobs:
@@ -17,7 +17,7 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        branch: [ '6.2.x', '7.0.x', 'main' ]
+        branch: [ '6.2.x', 'main' ]
    steps:
      - uses: spring-io/spring-doc-actions/update-antora-spring-ui@5a57bcc6a0da2a1474136cf29571b277850432bc
        name: Update
@@ -9,7 +9,6 @@ ivy-cache
 argfile*
 activemq-data/
 classes/
-.cursor/

 # Log files
 jxl.log
@@ -1,4 +1,4 @@
-# Contributing to the Spring Framework
+# Contributing  to the Spring Framework

 First off, thank you for taking the time to contribute! :+1: :tada: 

@@ -61,27 +61,25 @@ configure([rootProject] + javaProjects) { project ->
 		testImplementation("org.junit.platform:junit-platform-suite")
 		testImplementation("org.mockito:mockito-core")
 		testImplementation("org.mockito:mockito-junit-jupiter")
-		testImplementation("io.mockk:mockk") {
-			exclude group: 'junit', module: 'junit'
-		}
+		testImplementation("io.mockk:mockk")
 		testImplementation("org.assertj:assertj-core")
 		testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 		testRuntimeOnly("org.apache.logging.log4j:log4j-core")
 	}

 	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://www.quartz-scheduler.org/api/2.3.0/",
-		"https://hc.apache.org/httpcomponents-client-5.6.x/5.6/httpclient5/apidocs/",
-		"https://projectreactor.io/docs/core/release/api/",
-		"https://projectreactor.io/docs/test/release/api/",
-		"https://junit.org/junit4/javadoc/4.13.2/",
-		"https://docs.junit.org/6.1.0/api/",
-		"https://www.reactive-streams.org/reactive-streams-1.0.4-javadoc/",
-		"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
-		"https://jspecify.dev/docs/api/"
+			"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://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://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://r2dbc.io/spec/1.0.0.RELEASE/api/",
+			"https://jspecify.dev/docs/api/"
 	] as String[]
 }

@@ -20,7 +20,7 @@ ext {
 dependencies {
 	checkstyle "io.spring.javaformat:spring-javaformat-checkstyle:${javaFormatVersion}"
 	implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
-	implementation "org.jetbrains.dokka:dokka-gradle-plugin:2.2.0"
+	implementation "org.jetbrains.dokka:dokka-gradle-plugin:2.1.0"
 	implementation "com.tngtech.archunit:archunit:1.4.1"
 	implementation "org.gradle:test-retry-gradle-plugin:1.6.2"
 	implementation "io.spring.javaformat:spring-javaformat-gradle-plugin:${javaFormatVersion}"
@@ -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.4.2");
+			checkstyle.setToolVersion("13.2.0");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
 			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
@@ -49,8 +49,8 @@ javadoc {
 	maxMemory = "1024m"
 	doFirst {
 		classpath += files(
-			// ensure the javadoc process can resolve types compiled from .aj sources
-			springAspectsOutput
+				// ensure the javadoc process can resolve types compiled from .aj sources
+                springAspectsOutput
 		)
 		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
 	}
@@ -15,8 +15,8 @@ content:
    # 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: include all releases from 6.2.0 to 9.*.*.
-    tags: ['v6.2.+({0..9})', 'v{7..9}.+({0..9}).+({0..9})?(-{RC,M}*)']
+    # tags: We effectively include all releases from 6.0.9 to 9.*.*.
+    tags: ['v{6..9}.+({0..9}).+({0..9})?(-{RC,M}*)', '!(v6.0.{0..8})', '!(v6.0.0-{RC,M}{0..9})']
    start_path: framework-docs
 asciidoc:
  extensions:
@@ -38,4 +38,4 @@ runtime:
    failure_level: warn
 ui:
  bundle:
-    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.26/ui-bundle.zip
+    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.25/ui-bundle.zip
@@ -15,15 +15,11 @@ apply from: "${rootDir}/gradle/publications.gradle"
 antora {
 	options = [clean: true, fetch: !project.gradle.startParameter.offline, stacktrace: true]
 	environment = [
-		'BUILD_REFNAME': 'HEAD',
-		'BUILD_VERSION': project.version,
+			'BUILD_REFNAME': 'HEAD',
+			'BUILD_VERSION': project.version,
 	]
 }

-node {
-	version = '24.15.0'
-}
-
 tasks.named("generateAntoraYml") {
 	asciidocAttributes = project.provider( {
 		return  ["spring-version": project.version ]
@@ -53,8 +49,8 @@ tasks.withType(KotlinCompilationTask.class).configureEach {
 	javaSources.from = []
 	compilerOptions.jvmTarget = JvmTarget.JVM_17
 	compilerOptions.freeCompilerArgs.addAll(
-		"-Xjdk-release=17", // Needed due to https://youtrack.jetbrains.com/issue/KT-49746
-		"-Xannotation-default-target=param-property" // Upcoming default, see https://youtrack.jetbrains.com/issue/KT-73255
+			"-Xjdk-release=17", // Needed due to https://youtrack.jetbrains.com/issue/KT-49746
+			"-Xannotation-default-target=param-property" // Upcoming default, see https://youtrack.jetbrains.com/issue/KT-73255
 	)
 }

@@ -198,7 +198,6 @@
 *** xref:web/webmvc/mvc-uri-building.adoc[]
 *** xref:web/webmvc/mvc-ann-async.adoc[]
 *** xref:web/webmvc/mvc-range.adoc[]
-*** xref:web/webmvc/mvc-data-binding.adoc[]
 *** xref:web/webmvc-cors.adoc[]
 *** xref:web/webmvc-versioning.adoc[]
 *** xref:web/webmvc/mvc-ann-rest-exceptions.adoc[]
@@ -296,7 +295,6 @@
 *** xref:web/webflux-functional.adoc[]
 *** xref:web/webflux/uri-building.adoc[]
 *** xref:web/webflux/range.adoc[]
-*** xref:web/webflux/data-binding.adoc[]
 *** xref:web/webflux-cors.adoc[]
 *** xref:web/webflux-versioning.adoc[]
 *** xref:web/webflux/ann-rest-exceptions.adoc[]
@@ -332,10 +330,9 @@
 *** xref:testing/testcontext-framework/application-events.adoc[]
 *** xref:testing/testcontext-framework/test-execution-events.adoc[]
 *** xref:testing/testcontext-framework/ctx-management.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/xml.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/groovy.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/default-config.adoc[]
+**** xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/mixed-config.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/initializers.adoc[]
@@ -74,11 +74,6 @@ expressions used in XML bean definitions, `@Value`, etc.
 | The mode to use when compiling expressions for the
 xref:core/expressions/evaluation.adoc#expressions-compiler-configuration[Spring Expression Language].

-| `spring.expression.maxOperations`
-| The default maximum number of operations permitted during
-xref:core/expressions/evaluation.adoc#expressions-parser-configuration[Spring Expression Language]
-expression evaluation.
-
 | `spring.getenv.ignore`
 | Instructs Spring to ignore operating system environment variables if a Spring
 `Environment` property -- for example, a placeholder in a configuration String -- isn't
@@ -86,11 +81,6 @@ resolvable otherwise. See
 {spring-framework-api}++/core/env/AbstractEnvironment.html#IGNORE_GETENV_PROPERTY_NAME++[`AbstractEnvironment`]
 for details.

-| `spring.http.response.flush.enabled`
-| Configures the Spring MVC `ServletServerHttpResponse` to allow flushing on the `OutputStream`
-returned by `ServletServerHttpResponse#getBody()`. By default, such flush calls are ignored and
-only `ServletServerHttpResponse#flush()` will actually flush the response to the network.
-
 | `spring.jdbc.getParameterType.ignore`
 | Instructs Spring to ignore `java.sql.ParameterMetaData.getParameterType` completely.
 See the note in xref:data-access/jdbc/advanced.adoc#jdbc-batch-list[Batch Operations with a List of Objects].
@@ -143,11 +133,6 @@ xref:testing/testcontext-framework/ctx-management/context-pausing.adoc[Context P
 in the _Spring TestContext Framework_. See
 xref:testing/testcontext-framework/ctx-management/failure-threshold.adoc[Context Failure Threshold].

-| `spring.test.extension.context.scope`
-| The default _extension context scope_ used by the `SpringExtension` in `@Nested` test
-class hierarchies. See
-xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-springextensionconfig[`@SpringExtensionConfig`].
-
 | `spring.test.enclosing.configuration`
 | The default _enclosing configuration inheritance mode_ to use if
 `@NestedTestConfiguration` is not present on a test class. See
@@ -378,7 +378,7 @@ The container also supports creating a bean with {spring-framework-api}++/beans/

 . The custom arguments require dynamic introspection of a matching constructor or factory method.
 Those arguments cannot be detected by AOT, so the necessary reflection hints will have to be provided manually.
-. Bypassing the instance supplier means that all other optimizations after creation are skipped as well.
+. By-passing the instance supplier means that all other optimizations after creation are skipped as well.
 For instance, autowiring on fields and methods will be skipped as they are handled in the instance supplier.

 Rather than having prototype-scoped beans created with custom arguments, we recommend a manual factory pattern where a bean is responsible for the creation of the instance.
@@ -151,17 +151,17 @@ injected into a `Set<MovieCatalog>` annotated with `@Qualifier("action")`.
 [TIP]
 ====
 Letting qualifier values select against target bean names, within the type-matching
-candidates, does not require a `@Qualifier` annotation at the injection point. If there
-is no other resolution indicator (such as a qualifier, a primary marker, or a fallback
-marker), for a non-unique dependency situation, Spring matches the injection point name
-(that is, the field name or parameter name) against the target bean names and chooses the
-same-named candidate, if any (either by bean name or by associated alias).
+candidates, does not require a `@Qualifier` annotation at the injection point.
+If there is no other resolution indicator (such as a qualifier or a primary marker),
+for a non-unique dependency situation, Spring matches the injection point name
+(that is, the field name or parameter name) against the target bean names and chooses
+the same-named candidate, if any (either by bean name or by associated alias).

-Since version 6.1, this requires the `-parameters` Java compiler flag to be present. As
-of 6.2, the container applies fast shortcut resolution for bean name matches, bypassing
-the full type matching algorithm when the parameter name matches the bean name and no
-type, qualifier, primary, or fallback conditions override the match. It is therefore
-recommendable for your parameter names to match the target bean names.
+Since version 6.1, this requires the `-parameters` Java compiler flag to be present.
+As of 6.2, the container applies fast shortcut resolution for bean name matches,
+bypassing the full type matching algorithm when the parameter name matches the
+bean name and no type, qualifier or primary conditions override the match. It is
+therefore recommendable for your parameter names to match the target bean names.
 ====

 As an alternative for injection by name, consider the JSR-250 `@Resource` annotation
@@ -274,7 +274,7 @@ Kotlin::
 Next, you can provide the information for the candidate bean definitions. You can add
 `<qualifier/>` tags as sub-elements of the `<bean/>` tag and then specify the `type` and
 `value` to match your custom qualifier annotations. The type is matched against the
-fully-qualified class name of the annotation. Alternatively, as a convenience if no risk of
+fully-qualified class name of the annotation. Alternately, as a convenience if no risk of
 conflicting names exists, you can use the short class name. The following example
 demonstrates both approaches:

@@ -309,8 +309,7 @@ set of multiple matches for the specific bean type (as returned by the factory m

 Note that the standard `jakarta.annotation.Priority` annotation is not available at the
 `@Bean` level, since it cannot be declared on methods. Its semantics can be modeled
-through `@Order` values in combination with `@Primary` or `@Fallback` on a single bean
-for each type.
+through `@Order` values in combination with `@Primary` on a single bean for each type.
 ====

 Even typed `Map` instances can be autowired as long as the expected key type is `String`.
@@ -27,5 +27,4 @@ with the `CustomAutowireConfigurer`

 When multiple beans qualify as autowire candidates, the determination of a "`primary`" is
 as follows: If exactly one bean definition among the candidates has a `primary`
-attribute set to `true`, it is selected. For annotation-based configuration, see
-xref:core/beans/annotation-config/autowired-primary.adoc[Fine-tuning with `@Primary` or `@Fallback`].
+attribute set to `true`, it is selected.
@@ -556,11 +556,18 @@ Kotlin::
 ======

 If you do not want to rely on the default bean-naming strategy, you can provide a custom
-bean-naming strategy. First, implement either the
-{spring-framework-api}/beans/factory/support/BeanNameGenerator.html[`BeanNameGenerator`] or
-{spring-framework-api}/context/annotation/ConfigurationBeanNameGenerator.html[`ConfigurationBeanNameGenerator`]
+bean-naming strategy. First, implement the
+{spring-framework-api}/beans/factory/support/BeanNameGenerator.html[`BeanNameGenerator`]
 interface, and be sure to include a default no-arg constructor. Then, provide the fully
-qualified class name when configuring the scanner, as the following examples show.
+qualified class name when configuring the scanner, as the following example annotation
+and bean definition show.
+
+TIP: If you run into naming conflicts due to multiple autodetected components having the
+same non-qualified class name (i.e., classes with identical names but residing in
+different packages), you may need to configure a `BeanNameGenerator` that defaults to the
+fully qualified class name for the generated bean name. The
+`FullyQualifiedAnnotationBeanNameGenerator` located in package
+`org.springframework.context.annotation` can be used for such purposes.

 [tabs]
 ======
@@ -595,27 +602,6 @@ Kotlin::
 	</beans>
 ----

-[TIP]
-====
-If you run into naming conflicts due to multiple autodetected components having the same
-non-qualified class name (for example, classes with identical names but residing in
-different packages), you can configure a `BeanNameGenerator` that defaults to the
-fully-qualified class name for the generated bean name. The
-`FullyQualifiedAnnotationBeanNameGenerator` can be used for such purposes.
-
-As of Spring Framework 7.0, if you encounter naming conflicts among `@Bean` methods in
-`@Configuration` classes, you can alternatively configure a
-`ConfigurationBeanNameGenerator` that generates unique bean names for `@Bean` methods.
-The `FullyQualifiedConfigurationBeanNameGenerator` can be used to generate
-fully-qualified default bean names for `@Bean` methods without an explicit `name`
-attribute — for example, `com.example.MyConfig.myBean` for an `@Bean` method named
-`myBean()` declared in `@Configuration` class `com.example.MyConfig`.
-
-The `FullyQualifiedAnnotationBeanNameGenerator` and
-`FullyQualifiedConfigurationBeanNameGenerator` both reside in the
-`org.springframework.context.annotation` package.
-====
-
 As a general rule, consider specifying the name with the annotation whenever other
 components may be making explicit references to it. On the other hand, the
 auto-generated names are adequate whenever the container is responsible for wiring.
@@ -575,7 +575,7 @@ Kotlin::
 ----
 ======

-NOTE: Do not define such beans to be lazy as the `ApplicationContext` will honor that and will not register the method to listen to events.
+NOTE: Do not define such beans to be lazy as the `ApplicationContext` will honour that and will not register the method to listen to events.

 The method signature once again declares the event type to which it listens,
 but, this time, with a flexible name and without implementing a specific listener interface.
@@ -67,13 +67,6 @@ interface, clearly indicating the post-processor nature of that bean. Otherwise,
 Since a `BeanPostProcessor` needs to be instantiated early in order to apply to the
 initialization of other beans in the context, this early type detection is critical.

-Furthermore, when registering a `BeanPostProcessor` via an `@Bean` factory method,
-declare the method as `static` and ideally with no dependencies. Doing so avoids eager
-initialization of the configuration class and other beans, which would make them
-ineligible for full post-processing (such as auto-proxying). See the
-"BeanPostProcessor-returning `@Bean` methods" section in the
-{spring-framework-api}/context/annotation/Bean.html[`@Bean`] javadoc for details.
-
 [[beans-factory-programmatically-registering-beanpostprocessors]]
 .Programmatically registering `BeanPostProcessor` instances
 NOTE: While the recommended approach for `BeanPostProcessor` registration is through
@@ -87,7 +80,7 @@ of execution. Note also that `BeanPostProcessor` instances registered programmat
 are always processed before those registered through auto-detection, regardless of any
 explicit ordering.

-.`BeanPostProcessor` instances and early initialization
+.`BeanPostProcessor` instances and AOP auto-proxying
 [NOTE]
 ====
 Classes that implement the `BeanPostProcessor` interface are special and are treated
@@ -97,23 +90,17 @@ of the `ApplicationContext`. Next, all `BeanPostProcessor` instances are registe
 in a sorted fashion and applied to all further beans in the container. Because AOP
 auto-proxying is implemented as a `BeanPostProcessor` itself, neither `BeanPostProcessor`
 instances nor the beans they directly reference are eligible for auto-proxying and,
-thus, do not have aspects woven into them. More generally, any bean that is instantiated
-during this early phase is not eligible for full post-processing by all
-`BeanPostProcessor` instances.
+thus, do not have aspects woven into them.

-For any such bean, you should see a WARN-level log message similar to the following.
+For any such bean, you should see an informational log message: `Bean someBean is not
+eligible for getting processed by all BeanPostProcessor interfaces (for example: not
+eligible for auto-proxying)`.

-[quote]
-Bean 'someBean' of type [org.example.SomeType] is not eligible for getting processed by
-all BeanPostProcessors (for example: not eligible for auto-proxying).
-
-To minimize the number of beans affected, register a `BeanPostProcessor` with a
-`static` `@Bean` method that has no dependencies (see the note above). If you have
-beans wired into your `BeanPostProcessor` by using autowiring or `@Resource` (which
-may fall back to autowiring), Spring might access unexpected beans when searching
-for type-matching dependency candidates and, therefore, make them ineligible for
-auto-proxying or other kinds of bean post-processing. For example, if you have a
-dependency annotated with `@Resource` where the field or setter name does not
+If you have beans wired into your `BeanPostProcessor` by using autowiring or
+`@Resource` (which may fall back to autowiring), Spring might access unexpected beans
+when searching for type-matching dependency candidates and, therefore, make them
+ineligible for auto-proxying or other kinds of bean post-processing. For example, if you
+have a dependency annotated with `@Resource` where the field or setter name does not
 directly correspond to the declared name of a bean and no name attribute is used,
 Spring accesses other beans for matching them by type.
 ====
@@ -148,7 +135,7 @@ Java::
 		}

 		public Object postProcessAfterInitialization(Object bean, String beanName) {
-			System.out.println("Bean '" + beanName + "' created : " + bean);
+			System.out.println("Bean '" + beanName + "' created : " + bean.toString());
 			return bean;
 		}
 	}
@@ -177,48 +164,7 @@ Kotlin::
 ----
 ======

-You can register the `InstantiationTracingBeanPostProcessor` with Java configuration
-by using a `static` `@Bean` method (recommended to avoid eager initialization of the
-configuration class and other beans):
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",chomp="-packages"]
----
-	@Configuration
-	public class AppConfig {
-
-		@Bean
-		public static InstantiationTracingBeanPostProcessor instantiationTracingBeanPostProcessor() {
-			return new InstantiationTracingBeanPostProcessor();
-		}
-
-		// ... other bean definitions
-	}
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",chomp="-packages"]
----
-	@Configuration
-	class AppConfig {
-
-		@Bean
-		companion object {
-			@JvmStatic
-			fun instantiationTracingBeanPostProcessor() = InstantiationTracingBeanPostProcessor()
-		}
-
-		// ... other bean definitions
-	}
----
-======
-
-Alternatively, the `InstantiationTracingBeanPostProcessor` can be registered via the
-`bean` element with XML configuration:
+The following `beans` element uses the `InstantiationTracingBeanPostProcessor`:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -246,7 +192,7 @@ Alternatively, the `InstantiationTracingBeanPostProcessor` can be registered via
 ----

 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 with any
+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.)

@@ -354,23 +300,6 @@ implement the `BeanFactoryPostProcessor` interface. It uses these beans as bean
 post-processors, at the appropriate time. You can deploy these post-processor beans as
 you would any other bean.

-When registering a `BeanFactoryPostProcessor` via an `@Bean` factory method in a
-`@Configuration` class, declare the method as `static` to avoid lifecycle conflicts
-with annotation processing (such as `@Autowired`, `@Value`, and `@PostConstruct`) in the
-configuration class. See the "BeanFactoryPostProcessor-returning `@Bean` methods"
-section in the {spring-framework-api}/context/annotation/Bean.html[`@Bean`] javadoc
-for details and an example.
-
-For any non-static `@Bean` factory method with a `BeanFactoryPostProcessor` return type,
-you should see an INFO-level log message similar to the following.
-
-[quote]
-@Bean method MyConfig.myBfpp is non-static and returns an object assignable to Spring's
-BeanFactoryPostProcessor interface. This will result in a failure to process annotations
-such as @Autowired, @Resource, and @PostConstruct within the method's declaring
-@Configuration class. Add the 'static' modifier to this method to avoid these container
-lifecycle issues; see @Bean javadoc for complete details.
-
 NOTE: As with ``BeanPostProcessor``s , you typically do not want to configure
 ``BeanFactoryPostProcessor``s for lazy initialization. If no other bean references a
 `Bean(Factory)PostProcessor`, that post-processor will not get instantiated at all.
@@ -4,10 +4,10 @@
 `@Bean` is a method-level annotation and a direct analog of the XML `<bean/>` element.
 The annotation supports some of the attributes offered by `<bean/>`, such as:

-* xref:core/beans/definition.adoc#beans-beanname[name]
 * xref:core/beans/factory-nature.adoc#beans-factory-lifecycle-initializingbean[init-method]
 * xref:core/beans/factory-nature.adoc#beans-factory-lifecycle-disposablebean[destroy-method]
 * xref:core/beans/dependencies/factory-autowire.adoc[autowiring]
+* `name`.

 You can use the `@Bean` annotation in a `@Configuration`-annotated or in a
 `@Component`-annotated class.
@@ -17,10 +17,9 @@ You can use the `@Bean` annotation in a `@Configuration`-annotated or in a
 == Declaring a Bean

 To declare a bean, you can annotate a method with the `@Bean` annotation. You use this
-method to register a bean definition within an `ApplicationContext` of the type specified
-by the method's return type. By default, the bean name is the same as the method name
-(unless a different xref:#beans-java-customizing-bean-naming[bean name generator] is
-configured). The following example shows a `@Bean` method declaration:
+method to register a bean definition within an `ApplicationContext` of the type
+specified as the method's return value. By default, the bean name is the same as
+the method name. The following example shows a `@Bean` method declaration:

 [tabs]
 ======
@@ -127,7 +126,7 @@ Kotlin::
 ----
 ======

-However, this limits the visibility for advanced type prediction to the specified
+However, this limits the visibility for advance type prediction to the specified
 interface type (`TransferService`). Then, with the full type (`TransferServiceImpl`)
 known to the container only once the affected singleton bean has been instantiated.
 Non-lazy singleton beans get instantiated according to their declaration order,
@@ -474,15 +473,8 @@ Kotlin::
 == Customizing Bean Naming

 By default, configuration classes use a `@Bean` method's name as the name of the
-resulting bean. However, as of Spring Framework 7.0, you can change this default strategy
-by configuring a custom
-{spring-framework-api}/context/annotation/ConfigurationBeanNameGenerator.html[`ConfigurationBeanNameGenerator`]
-when bootstrapping the context or configuring component scanning. For example,
-{spring-framework-api}/context/annotation/FullyQualifiedConfigurationBeanNameGenerator.html[`FullyQualifiedConfigurationBeanNameGenerator`]
-can be used to generate fully-qualified default bean names for `@Bean` methods without an
-explicit `name` attribute. For individual `@Bean` methods, the default or
-generator-derived name can be overridden with the `name` attribute, as the following
-example shows:
+resulting bean. This functionality can be overridden, however, with the `name` attribute,
+as the following example shows:

 [tabs]
 ======
@@ -513,7 +505,6 @@ Kotlin::
 ----
 ======

-NOTE: `@Bean("myThing")` is equivalent to `@Bean(name = "myThing")`.

 [[beans-java-bean-aliasing]]
 == Bean Aliasing
@@ -610,19 +610,6 @@ Kotlin::
 See the {spring-framework-api}/context/annotation/Conditional.html[`@Conditional`]
 javadoc for more detail.

-[NOTE]
-====
-A `@Conditional` annotation declared on an enclosing `@Configuration` class is only
-applied to the registration of a nested `@Configuration` class if the nested class is
-reached through the parser's recursion from its enclosing class, or via `@Import`. If a
-nested class is discovered independently of its enclosing class — for example, via
-`@ComponentScan` or by directly registering it against the application context — it is
-processed using only its own `@Conditional` annotations. Thus, if you wish to ensure that
-the same `@Conditional` annotations apply in such scenarios, you must redeclare the
-relevant annotations on the nested class, or extract them into a composed annotation
-which you apply to both the enclosing class and the nested class.
-====
-

 [[beans-java-combining]]
 == Combining Java and XML Configuration
@@ -395,16 +395,6 @@ set a JVM system property or Spring property named `spring.context.expression.ma
 to the maximum expression length needed by your application (see
 xref:appendix.adoc#appendix-spring-properties[Supported Spring Properties]).

-Similarly, the number of operations performed during the evaluation of a SpEL expression
-cannot exceed 10,000 by default; however, the `maxOperations` value is configurable. If
-you create a `SpelExpressionParser` programmatically (the recommend approach), you can
-specify a custom `maxOperations` value when creating the `SpelParserConfiguration` that
-you provide to the `SpelExpressionParser`. If you are not able to configure an explicit
-value for `maxOperations` via `SpelParserConfiguration`, you can set a JVM system
-property or Spring property named `spring.expression.maxOperations` to the maximum number
-of operations required by your application (see
-xref:appendix.adoc#appendix-spring-properties[Supported Spring Properties]).
-

 [[expressions-spel-compilation]]
 == SpEL Compilation
@@ -541,6 +531,7 @@ following kinds of expressions cannot be compiled.
 * Expressions relying on the conversion service
 * Expressions using custom resolvers
 * Expressions using overloaded operators
+* Expressions using `Optional` with the null-safe or Elvis operator
 * Expressions using array construction syntax
 * Expressions using selection or projection
 * Expressions using bean references
@@ -2,12 +2,4 @@
 = Language Reference
 :page-section-summary-toc: 1

-Spring Expression Language (SpEL) expressions are composed of a sequence of tokens such
-as literals, operators, method invocations, and so forth.
-
-Whitespace can be used freely between tokens to format and improve the readability of
-expressions. Specifically, the `\s` (space), `\t` (tab), `\r` (carriage return), and `\n`
-(newline) characters are all valid separators between tokens. However, whitespace is
-ignored by the expression parser unless it is part of a string literal.
-
-The following sections describe the features and syntax of SpEL.
+This section describes how the Spring Expression Language works.
@@ -53,7 +53,7 @@ Kotlin::
 	val trueValue = parser.parseExpression("'black' < 'block'").getValue(Boolean::class.java)

 	// uses CustomValue:::compareTo
-	val trueValue = parser.parseExpression("new CustomValue(1) < new CustomValue(2)").getValue(Boolean::class.java)
+	val trueValue = parser.parseExpression("new CustomValue(1) < new CustomValue(2)").getValue(Boolean::class.java);
 ----
 ======

@@ -167,7 +167,7 @@ Kotlin::
 [CAUTION]
 ====
 The syntax for the `between` operator is `<input> between {<range_begin>, <range_end>}`,
-which is effectively a shortcut for `<input> >= <range_begin> && <input> \<= <range_end>`.
+which is effectively a shortcut for `<input> >= <range_begin> && <input> \<= <range_end>}`.

 Consequently, `1 between {1, 5}` evaluates to `true`, while `1 between {5, 1}` evaluates
 to `false`.
@@ -312,13 +312,13 @@ Kotlin::

 	// evaluates to 'a'
 	val ch = parser.parseExpression("'d' - 3")
-			.getValue(Char::class.java)
+			.getValue(Character::class.java);

 	// -- Repeat --

 	// evaluates to "abcabc"
 	val repeated = parser.parseExpression("'abc' * 2")
-			.getValue(String::class.java)
+			.getValue(String::class.java);
 ----
 ======

@@ -485,7 +485,7 @@ Kotlin::

 	// -- Operator precedence --

-	val minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Int::class.java)  // -21
+	val minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Int::class.java)  // -21	
 ----
 ======

@@ -541,7 +541,32 @@ For example, if we want to overload the `ADD` operator to allow two lists to be
 concatenated using the `+` sign, we can implement a custom `OperatorOverloader` as
 follows.

-include-code::./ListConcatenation[]
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	pubic class ListConcatenation implements OperatorOverloader {
+
+		@Override
+		public boolean overridesOperation(Operation operation, Object left, Object right) {
+			return (operation == Operation.ADD &&
+					left instanceof List && right instanceof List);
+		}
+
+		@Override
+		@SuppressWarnings("unchecked")
+		public Object operate(Operation operation, Object left, Object right) {
+			if (operation == Operation.ADD &&
+					left instanceof List list1 && right instanceof List list2) {
+
+				List result = new ArrayList(list1);
+				result.addAll(list2);
+				return result;
+			}
+			throw new UnsupportedOperationException(
+				"No overload for operation %s and operands [%s] and [%s]"
+					.formatted(operation, left, right));
+		}
+	}
+----

 If we register `ListConcatenation` as the `OperatorOverloader` in a
 `StandardEvaluationContext`, we can then evaluate expressions like `{1, 2, 3} + {4, 5}`
@@ -564,8 +589,8 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	val context = StandardEvaluationContext()
-	context.operatorOverloader = ListConcatenation()
+	StandardEvaluationContext context = StandardEvaluationContext()
+	context.setOperatorOverloader(ListConcatenation())

 	// evaluates to a new list: [1, 2, 3, 4, 5]
 	parser.parseExpression("{1, 2, 3} + {2 + 2, 5}").getValue(context, List::class.java)
@@ -270,7 +270,7 @@ is applicable for typical implementations of indexed structures.
 NOTE: `ReflectiveIndexAccessor` also implements `CompilableIndexAccessor` in order to
 support xref:core/expressions/evaluation.adoc#expressions-spel-compilation[compilation]
 to bytecode for read access. Note, however, that the configured read-method must be
-invocable via a `public` class or `public` interface for compilation to succeed.
+invokable via a `public` class or `public` interface for compilation to succeed.

 The following code listings define a `Color` enum and `FruitMap` type that behaves like a
 map but does not implement the `java.util.Map` interface. Thus, if you want to index into
@@ -25,8 +25,7 @@ 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. If all attempts have failed and the retry policy has been exhausted,
-the last original exception from the target method will be propagated to the caller.
+between attempts.

 [NOTE]
 ====
@@ -70,12 +69,12 @@ Or for 4 retry attempts and an exponential back-off strategy with a bit of jitte
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@Retryable(
-        includes = MessageDeliveryException.class,
-        maxRetries = 4,
-        delay = 100,
-        jitter = 10,
-        multiplier = 2,
-        maxDelay = 1000)
+  includes = MessageDeliveryException.class,
+  maxRetries = 4,
+  delay = 100,
+  jitter = 10,
+  multiplier = 2,
+  maxDelay = 1000)
 public void sendNotification() {
    this.jmsClient.destination("notifications").send(...);
 }
@@ -100,13 +99,6 @@ TIP: Several attributes in `@Retryable` have `String` variants that provide prop
 placeholder and SpEL support, as an alternative to the specifically typed annotation
 attributes used in the above examples.

-[TIP]
-====
-During `@Retryable` processing, Spring publishes a `MethodRetryEvent` for every exception
-coming out of the target method. This can be used to track/log all original exceptions
-whereas the caller of the `@Retryable` method will only ever see the last exception.
-====
-

 [[resilience-annotations-concurrencylimit]]
 == `@ConcurrencyLimit`
@@ -182,7 +174,7 @@ configured {spring-framework-api}/core/retry/RetryPolicy.html[`RetryPolicy`].
 ----
    var retryTemplate = new RetryTemplate(); // <1>

-    retryTemplate.invoke(
+    retryTemplate.execute(
            () -> jmsClient.destination("notifications").send(...));
 ----
 <1> Implicitly uses `RetryPolicy.withDefaults()`.
@@ -191,6 +183,9 @@ By default, a retryable operation will be retried for any exception thrown: with
 3 retry attempts (`maxRetries = 3`) 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`
@@ -201,14 +196,11 @@ For example, if `maxRetries` is set to `4`, the retryable operation will be invo
 least once and at most 5 times.
 ====

-If you only need to customize the number of retry attempts, you can use the
-`RetryPolicy.withMaxRetries()` factory method as demonstrated below.
-
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
    var retryTemplate = new RetryTemplate(RetryPolicy.withMaxRetries(4)); // <1>

-    retryTemplate.invoke(
+    retryTemplate.execute(
            () -> jmsClient.destination("notifications").send(...));
 ----
 <1> Explicitly uses `RetryPolicy.withMaxRetries(4)`.
@@ -226,7 +218,7 @@ matched against an exception thrown by a failed operation as well as nested caus

    var retryTemplate = new RetryTemplate(retryPolicy);

-    retryTemplate.invoke(
+    retryTemplate.execute(
            () -> jmsClient.destination("notifications").send(...));
 ----
 <1> Specify one or more exception types to include.
@@ -259,101 +251,21 @@ and an exponential back-off strategy with a bit of jitter.

    var retryTemplate = new RetryTemplate(retryPolicy);

-    retryTemplate.invoke(
+    retryTemplate.execute(
            () -> jmsClient.destination("notifications").send(...));
 ----

 [TIP]
 ====
+A {spring-framework-api}/core/retry/RetryListener.html[`RetryListener`] can be registered
+with a `RetryTemplate` to react to events published during key retry phases (before a
+retry attempt, after a retry attempt, etc.), and you can compose multiple listeners via a
+{spring-framework-api}/core/retry/support/CompositeRetryListener.html[`CompositeRetryListener`].
+====
+
 Although the factory methods and builder API for `RetryPolicy` cover most common
 configuration scenarios, you can implement a custom `RetryPolicy` for complete control
 over the types of exceptions that should trigger a retry as well as the
-{spring-framework-api}/util/backoff/BackOff.html[`BackOff`] strategy to use. Note that
-you can also configure a customized `BackOff` strategy via the `backOff()` method in
-the `RetryPolicy.Builder`.
-====
-
-Note that the examples above apply a pattern similar to `@Retryable` method invocations
-where the last original exception will be propagated to the caller, using the `invoke`
-variants on `RetryTemplate` which are available with and without a return value.
-The callback may throw unchecked exceptions, the last one of which is exposed for
-direct handling on the caller side:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-    try {
-        retryTemplate.invoke(
-                () -> jmsClient.destination("notifications").send(...));
-    }
-    catch (MessageDeliveryException ex) {
-        // coming out of the original JmsClient send method
-    }
----
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-    try {
-        var result = retryTemplate.invoke(() -> {
-            jmsClient.destination("notifications").send(...);
-            return "result";
-        });
-    }
-    catch (MessageDeliveryException ex) {
-        // coming out of the original JmsClient send method
-    }
----
-
-`RetryTemplate` instances are very light and can be created on the fly,
-potentially with a specific retry policy to use for a given invocation:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-    try {
-        new RetryTemplate(RetryPolicy.withMaxRetries(4)).invoke(
-                () -> jmsClient.destination("notifications").send(...));
-    }
-    catch (MessageDeliveryException ex) {
-        // coming out of the original JmsClient send method
-    }
----
-
-For deeper interaction, you may use RetryTemplate's `execute` method. The caller will
-have to handle the checked `RetryException` thrown by `RetryTemplate`, exposing the
-outcome of all attempts:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-    try {
-        var result = retryTemplate.execute(() -> {
-            jmsClient.destination("notifications").send(...);
-            return "result";
-        });
-    }
-    catch (RetryException ex) {
-        // ex.getExceptions() / ex.getLastException() ...
-    }
----
-
-A {spring-framework-api}/core/retry/RetryListener.html[`RetryListener`] can be registered
-with a `RetryTemplate` to react to key retry steps (before or after a retry attempt etc.)
-or simply to every invocation attempt, being able to track all exceptions coming out of
-the callback and all retry outcomes (exhaustion, interruption, timeout). This is
-particularly useful when using `invoke` where no retry state other than the last
-original exception is exposed otherwise:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-    var retryTemplate = new RetryTemplate();
-    retryTemplate.setRetryListener(new RetryListener() {
-        @Override
-        public void onRetryableExecution(RetryPolicy retryPolicy, Retryable<?> retryable, RetryState retryState) {
-            ...
-        }
-    });
-
-    retryTemplate.invoke(
-            () -> jmsClient.destination("notifications").send(...));
----
-
-You can also compose multiple listeners via a
-{spring-framework-api}/core/retry/support/CompositeRetryListener.html[`CompositeRetryListener`].
+{spring-framework-api}/util/backoff/BackOff.html[`BackOff`] strategy to use. Note that you
+can also configure a customized `BackOff` strategy via the `backOff()` method in the
+`RetryPolicy.Builder`.
@@ -347,10 +347,10 @@ recognized and used as the `PropertyEditor` for `Something`-typed properties.
 [literal,subs="verbatim,quotes"]
 ----
 com
-└── example
-    └── things
-        ├── *Something*
-        └── *SomethingEditor* // the PropertyEditor for the Something class
+  chank
+    pop
+      Something
+      SomethingEditor // the PropertyEditor for the Something class
 ----

 Note that you can also use the standard `BeanInfo` JavaBeans mechanism here as well
@@ -362,10 +362,10 @@ following example uses the `BeanInfo` mechanism to explicitly register one or mo
 [literal,subs="verbatim,quotes"]
 ----
 com
-└── example
-    └── things
-        ├── *Something*
-        └── *SomethingBeanInfo* // the BeanInfo for the Something class
+  chank
+    pop
+      Something
+      SomethingBeanInfo // the BeanInfo for the Something class
 ----

 The following Java source code for the referenced `SomethingBeanInfo` class
@@ -8,7 +8,7 @@ danger of undue coupling, because code that is meant to be used transactionally
 almost always deployed that way anyway.

 NOTE: The standard `jakarta.transaction.Transactional` annotation is also supported as
-a drop-in replacement for Spring's own annotation. Please refer to the JTA documentation
+a drop-in replacement to Spring's own annotation. Please refer to the JTA documentation
 for more details.

 The ease-of-use afforded by the use of the `@Transactional` annotation is best
@@ -89,16 +89,47 @@ annotation in a `@Configuration` class. See the
 {spring-framework-api}/transaction/annotation/EnableTransactionManagement.html[javadoc]
 for full details.

-The following example shows the configuration needed to enable annotation-driven transaction management:
+In XML configuration, the `<tx:annotation-driven/>` tag provides similar convenience:

-include-code::./AppConfig[tag=snippet,indent=0]
+[source,xml,indent=0,subs="verbatim,quotes"]
+----
+	<!-- from the file 'context.xml' -->
+	<?xml version="1.0" encoding="UTF-8"?>
+	<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xmlns:tx="http://www.springframework.org/schema/tx"
+		xsi:schemaLocation="
+			http://www.springframework.org/schema/beans
+			https://www.springframework.org/schema/beans/spring-beans.xsd
+			http://www.springframework.org/schema/tx
+			https://www.springframework.org/schema/tx/spring-tx.xsd
+			http://www.springframework.org/schema/aop
+			https://www.springframework.org/schema/aop/spring-aop.xsd">

-TIP: In programmatic configuration, the `@EnableTransactionManagement` annotation uses any
-`TransactionManager` bean in the context. In XML configuration, you can omit
-the `transaction-manager` attribute in the `<tx:annotation-driven/>` tag if the bean
-name of the `TransactionManager` that you want to wire in has the name `transactionManager`.
-If the `TransactionManager` bean has any other name, you have to use the
-`transaction-manager` attribute explicitly, as in the preceding example.
+		<!-- this is the service object that we want to make transactional -->
+		<bean id="fooService" class="x.y.service.DefaultFooService"/>
+
+		<!-- enable the configuration of transactional behavior based on annotations -->
+		<!-- a TransactionManager is still required -->
+		<tx:annotation-driven transaction-manager="txManager"/> <1>
+
+		<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
+			<!-- (this dependency is defined somewhere else) -->
+			<property name="dataSource" ref="dataSource"/>
+		</bean>
+
+		<!-- other <bean/> definitions here -->
+
+	</beans>
+----
+<1> The line that makes the bean instance transactional.
+
+TIP: You can omit the `transaction-manager` attribute in the `<tx:annotation-driven/>`
+tag if the bean name of the `TransactionManager` that you want to wire in has the name
+`transactionManager`. If the `TransactionManager` bean that you want to dependency-inject
+has any other name, you have to use the `transaction-manager` attribute, as in the
+preceding example.

 Reactive transactional methods use reactive return types in contrast to imperative
 programming arrangements as the following listing shows:
@@ -203,10 +234,8 @@ on an interface, a class definition, or a method on a class. However, the mere p
 of the `@Transactional` annotation is not enough to activate the transactional behavior.
 The `@Transactional` annotation is merely metadata that can be consumed by corresponding
 runtime infrastructure which uses that metadata to configure the appropriate beans with
-transactional behavior. In the preceding examples that use programmatic configuration,
-the `@EnableTransactionManagement` annotation switches on actual transaction management
-at runtime. Whereas, in the preceding example that uses XML configuration, the
-`<tx:annotation-driven/>` element switches on actual transaction management at runtime.
+transactional behavior. In the preceding example, the `<tx:annotation-driven/>` element
+switches on actual transaction management at runtime.

 TIP: The Spring team recommends that you annotate methods of concrete classes with the
 `@Transactional` annotation, rather than relying on annotated methods in interfaces,
@@ -22,7 +22,7 @@ where all the underlying resources have to participate in the service-level tran

 NOTE: By default, a participating transaction joins the characteristics of the outer scope,
 silently ignoring the local isolation level, timeout value, or read-only flag (if any).
-Consider switching the `validateExistingTransaction` flag to `true` on your transaction
+Consider switching the `validateExistingTransactions` flag to `true` on your transaction
 manager if you want isolation level declarations to be rejected when participating in
 an existing transaction with a different isolation level. This non-lenient mode also
 rejects read-only mismatches (that is, an inner read-write transaction that tries to participate
@@ -1,15 +1,10 @@
 [[observability]]
 = Observability Support

-With https://docs.micrometer.io/micrometer/reference/concepts.html[Micrometer], developers can instrument libraries and applications for metrics (timers, gauges, counters)
-that collect statistics about their runtime behavior. Metrics can help you to track error rates, usage patterns, performance, and more.
-https://docs.micrometer.io/tracing/reference/[Micrometer can also produce traces], giving you a holistic view of an entire system, crossing application boundaries; you can zoom in on particular user requests and follow their entire completion across applications.
-
 Micrometer defines an {micrometer-docs}/observation.html[Observation concept that enables both Metrics and Traces] in applications.
-Each observation will produce:
-
-* https://docs.micrometer.io/micrometer/reference/observation/components.html#micrometer-observation-default-meter-handler[several metrics - a timer, a long task timer and many counters]
-* a https://docs.micrometer.io/tracing/reference/glossary.html[span for the current trace]
+Metrics support offers a way to create timers, gauges, or counters for collecting statistics about the runtime behavior of your application.
+Metrics can help you to track error rates, usage patterns, performance, and more.
+Traces provide a holistic view of an entire system, crossing application boundaries; you can zoom in on particular user requests and follow their entire completion across applications.

 Spring Framework instruments various parts of its own codebase to publish observations if an `ObservationRegistry` is configured.
 You can learn more about {spring-boot-docs-ref}/actuator/observability.html[configuring the observability infrastructure in Spring Boot].
@@ -402,27 +402,6 @@ To serialize only a subset of the object properties, you can specify a {baeldung
 		.toBodilessEntity();
 ----

-==== URL encoded Forms
-
-URL encoded forms, using the `"application/x-www-form-urlencoded"` media type, are useful for sending String key/values over the wire.
-This is supported by the `FormHttpMessageConverter`, if the application uses a `MultiValueMap<String, String>` as source instance
-or a target type.
-
-For example:
-
-[source,java,indent=0,subs="verbatim"]
----
-    MultiValueMap<String, String> form = new LinkedMultiValueMap<>();
-    form.add("project", "Spring Framework");
-    form.add("module", "spring-web");
-    ResponseEntity<Void> response = this.restClient.post()
-            .contentType(MediaType.APPLICATION_FORM_URLENCODED)
-            .body(form)
-            .retrieve()
-            .toBodilessEntity();
----
-
-
 ==== Multipart

 To send multipart data, you need to provide a `MultiValueMap<String, Object>` whose values may be an `Object` for part content, a `Resource` for a file part, or an `HttpEntity` for part content with headers.
@@ -440,70 +419,18 @@ For example:
 	headers.setContentType(MediaType.APPLICATION_XML);
 	parts.add("xmlPart", new HttpEntity<>(myBean, headers));
 	
-    ResponseEntity<Void> response = this.restClient.post()
-            .contentType(MediaType.MULTIPART_FORM_DATA)
-            .body(parts)
-            .retrieve()
-            .toBodilessEntity();
+	// send using RestClient.post or RestTemplate.postForEntity
 ----

 In most cases, you do not have to specify the `Content-Type` for each part.
 The content type is determined automatically based on the `HttpMessageConverter` chosen to serialize it or, in the case of a `Resource`, based on the file extension.
 If necessary, you can explicitly provide the `MediaType` with an `HttpEntity` wrapper.

-The `Content-Type` is set to `multipart/form-data` by the `MultipartHttpMessageConverter`.
-As seen in the previous section, `MultiValueMap` types can also be used for URL encoded forms.
-It is preferable to explicitly set the media type in the `Content-Type` or `Accept` HTTP request headers to ensure that the expected
-message converter is used.
-
-`RestClient` can also receive multipart responses.
-To decode a multipart response body, use a `ParameterizedTypeReference<MultiValueMap<String, Part>>`.
-The decoded map contains `Part` instances where `FormFieldPart` represents form field values
-and `FilePart` represents file parts with a `filename()` and a `transferTo()` method.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim"]
----
-	MultiValueMap<String, Part> result = this.restClient.get()
-			.uri("https://example.com/upload")
-			.accept(MediaType.MULTIPART_FORM_DATA)
-			.retrieve()
-			.body(new ParameterizedTypeReference<>() {});
-
-	Part field = result.getFirst("fieldPart");
-	if (field instanceof FormFieldPart formField) {
-		String fieldValue = formField.value();
-	}
-	Part file = result.getFirst("filePart");
-	if (file instanceof FilePart filePart) {
-		filePart.transferTo(Path.of("/tmp/" + filePart.filename()));
-	}
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim"]
----
-	val result = this.restClient.get()
-			.uri("https://example.com/upload")
-			.accept(MediaType.MULTIPART_FORM_DATA)
-			.retrieve()
-			.body(object : ParameterizedTypeReference<MultiValueMap<String, Part>>() {})
-
-	val field = result?.getFirst("fieldPart")
-	if (field is FormFieldPart) {
-		val fieldValue = field.value()
-	}
-	val file = result?.getFirst("filePart")
-	if (file is FilePart) {
-		file.transferTo(Path.of("/tmp/" + file.filename()))
-	}
----
-======
+Once the `MultiValueMap` is ready, you can use it as the body of a `POST` request, using `RestClient.post().body(parts)` (or `RestTemplate.postForObject`).

+If the `MultiValueMap` contains at least one non-`String` value, the `Content-Type` is set to `multipart/form-data` by the `FormHttpMessageConverter`.
+If the `MultiValueMap` has `String` values, the `Content-Type` defaults to `application/x-www-form-urlencoded`.
+If necessary the `Content-Type` may also be set explicitly.

 [[rest-request-factories]]
 === Client Request Factories
@@ -1252,7 +1179,7 @@ built-in decorators to suppress 404 exceptions and return a `ResponseEntity` wit
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	// For RestClient
-	HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(restClientAdapter)
+	HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(restCqlientAdapter)
 			.exchangeAdapterDecorator(NotFoundRestClientAdapterDecorator::new)
 			.build();

@@ -3,7 +3,7 @@

 The following annotations are supported when used in conjunction with the
 xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-extension[`SpringExtension`]
-and the JUnit Jupiter testing framework:
+and JUnit Jupiter (that is, the programming model in JUnit):

 * xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-springextensionconfig[`@SpringExtensionConfig`]
 * xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-junit-jupiter-springjunitconfig[`@SpringJUnitConfig`]
@@ -30,39 +30,30 @@ developer wishes to switch to test-class scoped semantics — the `SpringExtensi
 configured to use a test-class scoped `ExtensionContext` by annotating a top-level test
 class with `@SpringExtensionConfig(useTestClassScopedExtensionContext = true)`.

-Alternatively, you can change the global default by setting the
-`spring.test.extension.context.scope` property to `test_class`. The property is resolved
-first via the xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism
-which also supports JVM system properties — for example,
-`-Dspring.test.extension.context.scope=test_class`. If the Spring property has not been
-set, the `SpringExtension` will attempt to resolve the property as a
-https://docs.junit.org/current/running-tests/configuration-parameters.html[JUnit Platform configuration parameter]
-as a fallback mechanism. If the property has not been set via either of those mechanisms,
-the `SpringExtension` will use a test-method scoped extension context by default. Note,
-however, that a `@SpringExtensionConfig` declaration always takes precedence over this
-property.
-
 [TIP]
 ====
-If a test class uses JUnit Jupiter's `@TestInstance(Lifecycle.PER_CLASS)` semantics, the
-`SpringExtension` will always use a test-class scoped `ExtensionContext`, and
-configuration via `@SpringExtensionConfig(useTestClassScopedExtensionContext = true)` or
-the `spring.test.extension.context.scope` property will have no effect for that test
-class.
+If your top-level test class is configured to use JUnit Jupiter's
+`@TestInstance(Lifecycle.PER_CLASS)` semantics, the `SpringExtension` will always use a
+test-class scoped `ExtensionContext`, and there is no need to declare
+`@SpringExtensionConfig(useTestClassScopedExtensionContext = true)`.
 ====

 [NOTE]
 ====
 This annotation is currently only applicable to `@Nested` test class hierarchies and
 should be applied to the top-level enclosing class of a `@Nested` test class hierarchy.
+
 Consequently, there is no need to declare this annotation on a test class that does not
 contain `@Nested` test classes.
+====

-In addition,
+[NOTE]
+====
 xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-nestedtestconfiguration[`@NestedTestConfiguration`]
-does not apply to this annotation. `@SpringExtensionConfig` will always be detected
-within a `@Nested` test class hierarchy, effectively disregarding any
-`@NestedTestConfiguration(OVERRIDE)` declarations.
+does not apply to this annotation.
+
+`@SpringExtensionConfig` will always be detected within a `@Nested` test class hierarchy,
+effectively disregarding any `@NestedTestConfiguration(OVERRIDE)` declarations.
 ====

 [[integration-testing-annotations-junit-jupiter-springjunitconfig]]
@@ -72,13 +72,6 @@ bean definition profiles programmatically by implementing a custom
 xref:testing/testcontext-framework/ctx-management/env-profiles.adoc#testcontext-ctx-management-env-profiles-ActiveProfilesResolver[`ActiveProfilesResolver`]
 and registering it by using the `resolver` attribute of `@ActiveProfiles`.

-NOTE: When `@ActiveProfiles` is declared on a test class, the `spring.profiles.active`
-property (whether configured as a JVM system property or environment variable) is not
-taken into account by the TestContext Framework when determining active profiles. If
-you need to allow `spring.profiles.active` to override the profiles configured via
-`@ActiveProfiles`, you can implement a custom `ActiveProfilesResolver` as described in
-xref:testing/testcontext-framework/ctx-management/env-profiles.adoc[Context Configuration with Environment Profiles].
-
 See xref:testing/testcontext-framework/ctx-management/env-profiles.adoc[Context Configuration with Environment Profiles],
 xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-nested-test-configuration[`@Nested` test class configuration], and the
 {spring-framework-api}/test/context/ActiveProfiles.html[`@ActiveProfiles`] javadoc for
@@ -12,20 +12,18 @@ The annotations can be applied in the following ways.
 * On a non-static field in a test class or any of its superclasses.
 * On a non-static field in an enclosing class for a `@Nested` test class or in any class
  in the type hierarchy or enclosing class hierarchy above the `@Nested` test class.
-* On a parameter in the constructor for a test class.
 * At the type level on a test class or any superclass or implemented interface in the
  type hierarchy above the test class.
 * At the type level on an enclosing class for a `@Nested` test class or on any class or
  interface in the type hierarchy or enclosing class hierarchy above the `@Nested` test
  class.

-When `@MockitoBean` or `@MockitoSpyBean` is declared on a field or constructor parameter,
-the bean to mock or spy is inferred from the type of the annotated field or parameter. If
-multiple candidates exist in the `ApplicationContext`, a `@Qualifier` annotation can be
-declared on the field or parameter to help disambiguate. In the absence of a `@Qualifier`
-annotation, the name of the annotated field or parameter will be used as a _fallback
-qualifier_. Alternatively, you can explicitly specify a bean name to mock or spy by
-setting the `value` or `name` attribute in the annotation.
+When `@MockitoBean` or `@MockitoSpyBean` is declared on a field, the bean to mock or spy
+is inferred from the type of the annotated field. If multiple candidates exist in the
+`ApplicationContext`, a `@Qualifier` annotation can be declared on the field to help
+disambiguate. In the absence of a `@Qualifier` annotation, the name of the annotated
+field will be used as a _fallback qualifier_. Alternatively, you can explicitly specify a
+bean name to mock or spy by setting the `value` or `name` attribute in the annotation.

 When `@MockitoBean` or `@MockitoSpyBean` is declared at the type level, the type of bean
 (or beans) to mock or spy must be supplied via the `types` attribute in the annotation –
@@ -142,21 +140,6 @@ Java::
 	}
 ----
 <1> Replace the bean with type `CustomService` with a Mockito mock.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	class BeanOverrideTests {
-
-		@MockitoBean // <1>
-		lateinit var customService: CustomService
-
-		// tests...
-	}
----
-<1> Replace the bean with type `CustomService` with a Mockito mock.
 ======

 In the example above, we are creating a mock for `CustomService`. If more than one bean
@@ -185,98 +168,6 @@ Java::
 	}
 ----
 <1> Replace the bean named `service` with a Mockito mock.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	class BeanOverrideTests {
-
-		@MockitoBean("service") // <1>
-		lateinit var customService: CustomService
-
-		// tests...
-
-	}
----
-<1> Replace the bean named `service` with a Mockito mock.
-======
-
-The following example shows how to use `@MockitoBean` on a constructor parameter for a
-by-type lookup.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig.class)
-	class BeanOverrideTests {
-
-		private final CustomService customService;
-
-		BeanOverrideTests(@MockitoBean CustomService customService) { // <1>
-			this.customService = customService;
-		}
-
-		// tests...
-	}
----
-<1> Replace the bean with type `CustomService` with a Mockito mock and inject it into
-    the constructor.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	class BeanOverrideTests(@MockitoBean val customService: CustomService) { // <1>
-
-		// tests...
-	}
----
-<1> Replace the bean with type `CustomService` with a Mockito mock and inject it into
-    the constructor.
-======
-
-The following example shows how to use `@MockitoBean` on a constructor parameter for a
-by-name lookup.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig.class)
-	class BeanOverrideTests {
-
-		private final CustomService customService;
-
-		BeanOverrideTests(@MockitoBean("service") CustomService customService) { // <1>
-			this.customService = customService;
-		}
-
-		// tests...
-	}
----
-<1> Replace the bean named `service` with a Mockito mock and inject it into the
-    constructor.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	class BeanOverrideTests(@MockitoBean("service") val customService: CustomService) { // <1>
-
-		// tests...
-	}
----
-<1> Replace the bean named `service` with a Mockito mock and inject it into the
-    constructor.
 ======

 The following `@SharedMocks` annotation registers two mocks by-type and one mock by-name.
@@ -296,19 +187,6 @@ Java::
 ----
 <1> Register `OrderService` and `UserService` mocks by-type.
 <2> Register `PrintingService` mock by-name.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@Target(AnnotationTarget.CLASS)
-	@Retention(AnnotationRetention.RUNTIME)
-	@MockitoBean(types = [OrderService::class, UserService::class]) // <1>
-	@MockitoBean(name = "ps1", types = [PrintingService::class]) // <2>
-	annotation class SharedMocks
----
-<1> Register `OrderService` and `UserService` mocks by-type.
-<2> Register `PrintingService` mock by-name.
 ======

 The following demonstrates how `@SharedMocks` can be used on a test class.
@@ -339,34 +217,6 @@ Java::
 ----
 <1> Register common mocks via the custom `@SharedMocks` annotation.
 <2> Optionally inject mocks to _stub_ or _verify_ them.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	@SharedMocks // <1>
-	class BeanOverrideTests {
-
-		@Autowired
-		lateinit var orderService: OrderService // <2>
-
-		@Autowired
-		lateinit var userService: UserService // <2>
-
-		@Autowired
-		lateinit var ps1: PrintingService // <2>
-
-		// Inject other components that rely on the mocks.
-
-		@Test
-		fun testThatDependsOnMocks() {
-			// ...
-		}
-	}
----
-<1> Register common mocks via the custom `@SharedMocks` annotation.
-<2> Optionally inject mocks to _stub_ or _verify_ them.
 ======

 TIP: The mocks can also be injected into `@Configuration` classes or other test-related
@@ -396,21 +246,6 @@ Java::
 	}
 ----
 <1> Wrap the bean with type `CustomService` with a Mockito spy.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	class BeanOverrideTests {
-
-		@MockitoSpyBean // <1>
-		lateinit var customService: CustomService
-
-		// tests...
-	}
----
-<1> Wrap the bean with type `CustomService` with a Mockito spy.
 ======

 In the example above, we are wrapping the bean with type `CustomService`. If more than
@@ -436,95 +271,6 @@ Java::
 	}
 ----
 <1> Wrap the bean named `service` with a Mockito spy.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	class BeanOverrideTests {
-
-		@MockitoSpyBean("service") // <1>
-		lateinit var customService: CustomService
-
-		// tests...
-	}
----
-<1> Wrap the bean named `service` with a Mockito spy.
-======
-
-The following example shows how to use `@MockitoSpyBean` on a constructor parameter for
-a by-type lookup.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig.class)
-	class BeanOverrideTests {
-
-		private final CustomService customService;
-
-		BeanOverrideTests(@MockitoSpyBean CustomService customService) { // <1>
-			this.customService = customService;
-		}
-
-		// tests...
-	}
----
-<1> Wrap the bean with type `CustomService` with a Mockito spy and inject it into the
-    constructor.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	class BeanOverrideTests(@MockitoSpyBean val customService: CustomService) { // <1>
-
-		// tests...
-	}
----
-<1> Wrap the bean with type `CustomService` with a Mockito spy and inject it into the
-    constructor.
-======
-
-The following example shows how to use `@MockitoSpyBean` on a constructor parameter for
-a by-name lookup.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig.class)
-	class BeanOverrideTests {
-
-		private final CustomService customService;
-
-		BeanOverrideTests(@MockitoSpyBean("service") CustomService customService) { // <1>
-			this.customService = customService;
-		}
-
-		// tests...
-	}
----
-<1> Wrap the bean named `service` with a Mockito spy and inject it into the constructor.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	class BeanOverrideTests(@MockitoSpyBean("service") val customService: CustomService) { // <1>
-
-		// tests...
-	}
----
-<1> Wrap the bean named `service` with a Mockito spy and inject it into the constructor.
 ======

 The following `@SharedSpies` annotation registers two spies by-type and one spy by-name.
@@ -544,19 +290,6 @@ Java::
 ----
 <1> Register `OrderService` and `UserService` spies by-type.
 <2> Register `PrintingService` spy by-name.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@Target(AnnotationTarget.CLASS)
-	@Retention(AnnotationRetention.RUNTIME)
-	@MockitoSpyBean(types = [OrderService::class, UserService::class]) // <1>
-	@MockitoSpyBean(name = "ps1", types = [PrintingService::class]) // <2>
-	annotation class SharedSpies
----
-<1> Register `OrderService` and `UserService` spies by-type.
-<2> Register `PrintingService` spy by-name.
 ======

 The following demonstrates how `@SharedSpies` can be used on a test class.
@@ -587,34 +320,6 @@ Java::
 ----
 <1> Register common spies via the custom `@SharedSpies` annotation.
 <2> Optionally inject spies to _stub_ or _verify_ them.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig::class)
-	@SharedSpies // <1>
-	class BeanOverrideTests {
-
-		@Autowired
-		lateinit var orderService: OrderService // <2>
-
-		@Autowired
-		lateinit var userService: UserService // <2>
-
-		@Autowired
-		lateinit var ps1: PrintingService // <2>
-
-		// Inject other components that rely on the spies.
-
-		@Test
-		fun testThatDependsOnMocks() {
-			// ...
-		}
-	}
----
-<1> Register common spies via the custom `@SharedSpies` annotation.
-<2> Optionally inject spies to _stub_ or _verify_ them.
 ======

 TIP: The spies can also be injected into `@Configuration` classes or other test-related
@@ -73,27 +73,6 @@ Java::
 ----
 <1> Mark a field for overriding the bean with type `CustomService`.
 <2> The result of this static method will be used as the instance and injected into the field.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	class OverrideBeanTests {
-		@TestBean // <1>
-		lateinit var customService: CustomService
-
-		// test case body...
-
-		companion object {
-			@JvmStatic
-			fun customService(): CustomService { // <2>
-				return MyFakeCustomService()
-			}
-		}
-	}
----
-<1> Mark a field for overriding the bean with type `CustomService`.
-<2> The result of this static method will be used as the instance and injected into the field.
 ======

 In the example above, we are overriding the bean with type `CustomService`. If more than
@@ -123,28 +102,6 @@ Java::
 <1> Mark a field for overriding the bean with name `service`, and specify that the
    factory method is named `createCustomService`.
 <2> The result of this static method will be used as the instance and injected into the field.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	class OverrideBeanTests {
-		@TestBean(name = "service", methodName = "createCustomService") // <1>
-		lateinit var customService: CustomService
-
-		// test case body...
-
-		companion object {
-			@JvmStatic
-			fun createCustomService(): CustomService { // <2>
-				return MyFakeCustomService()
-			}
-		}
-	}
----
-<1> Mark a field for overriding the bean with name `service`, and specify that the
-    factory method is named `createCustomService`.
-<2> The result of this static method will be used as the instance and injected into the field.
 ======

 [TIP]
@@ -3,7 +3,7 @@

 In the previous sections, we have seen how to use MockMvc in conjunction with the raw
 HtmlUnit APIs. In this section, we use additional abstractions within the Selenium
-https://www.selenium.dev/documentation/webdriver/[WebDriver] to make things even easier.
+https://docs.seleniumhq.org/projects/webdriver/[WebDriver] to make things even easier.

 [[mockmvc-server-htmlunit-webdriver-why]]
 == Why WebDriver and MockMvc?
@@ -12,8 +12,8 @@ We can already use HtmlUnit and MockMvc, so why would we want to use WebDriver?
 Selenium WebDriver provides a very elegant API that lets us easily organize our code. To
 better show how it works, we explore an example in this section.

-NOTE: Despite being a part of https://www.selenium.dev/documentation/[Selenium],
-WebDriver does not require a Selenium Server to run your tests.
+NOTE: Despite being a part of https://docs.seleniumhq.org/[Selenium], WebDriver does not
+require a Selenium Server to run your tests.

 Suppose we need to ensure that a message is created properly. The tests involve finding
 the HTML form input elements, filling them out, and making various assertions.
@@ -308,7 +308,7 @@ interested. These are of type `WebElement`. WebDriver's
 https://github.com/SeleniumHQ/selenium/wiki/PageFactory[`PageFactory`] lets us remove a
 lot of code from the HtmlUnit version of `CreateMessagePage` by automatically resolving
 each `WebElement`. The
-https://www.selenium.dev/selenium/docs/api/java/org/openqa/selenium/support/PageFactory.html#initElements-org.openqa.selenium.WebDriver-java.lang.Class-[`PageFactory#initElements(WebDriver,Class<T>)`]
+https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/PageFactory.html#initElements-org.openqa.selenium.WebDriver-java.lang.Class-[`PageFactory#initElements(WebDriver,Class<T>)`]
 method automatically resolves each `WebElement` by using the field name and looking it up
 by the `id` or `name` of the element within the HTML page.
 <3> We can use the
@@ -352,7 +352,7 @@ interested. These are of type `WebElement`. WebDriver's
 https://github.com/SeleniumHQ/selenium/wiki/PageFactory[`PageFactory`] lets us remove a
 lot of code from the HtmlUnit version of `CreateMessagePage` by automatically resolving
 each `WebElement`. The
-https://www.selenium.dev/selenium/docs/api/java/org/openqa/selenium/support/PageFactory.html#initElements-org.openqa.selenium.WebDriver-java.lang.Class-[`PageFactory#initElements(WebDriver,Class<T>)`]
+https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/PageFactory.html#initElements-org.openqa.selenium.WebDriver-java.lang.Class-[`PageFactory#initElements(WebDriver,Class<T>)`]
 method automatically resolves each `WebElement` by using the field name and looking it up
 by the `id` or `name` of the element within the HTML page.
 <3> We can use the
@@ -142,9 +142,6 @@ provides two alternative ways to verify the response:
 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

-TIP: See the xref:integration/rest-clients.adoc#rest-message-conversion[HTTP Message Conversion]
-section for examples on how to prepare a request with any content, including form data and multipart data.
-


 [[resttestclient.workflow]]
@@ -216,16 +213,6 @@ To verify JSON content with https://github.com/jayway/JsonPath[JSONPath]:
 include-code::./JsonTests[tag=jsonPath,indent=0]


-[[resttestclient.multipart]]
-==== Multipart Content
-
-When testing endpoints that return multipart responses, you can decode the body to a
-`MultiValueMap<String, Part>` and assert individual parts using the `FormFieldPart`
-and `FilePart` subtypes.
-
-include-code::./MultipartTests[tag=multipart,indent=0]
-
-
 [[resttestclient.assertj]]
 === AssertJ Integration

@@ -2,9 +2,8 @@
 = Bean Overriding in Tests

 Bean overriding in tests refers to the ability to override specific beans in the
-`ApplicationContext` for a test class, by annotating the test class, one or more
-non-static fields in the test class, or one or more parameters in the constructor for the
-test class.
+`ApplicationContext` for a test class, by annotating the test class or one or more
+non-static fields in the test class.

 NOTE: This feature is intended as a less risky alternative to the practice of registering
 a bean via `@Bean` with the `DefaultListableBeanFactory`
@@ -43,9 +42,9 @@ The `spring-test` module registers implementations of the latter two
 {spring-framework-code}/spring-test/src/main/resources/META-INF/spring.factories[`META-INF/spring.factories`
 properties file].

-The bean overriding infrastructure searches for annotations on test classes, non-static
-fields in test classes, and parameters in test class constructors that are meta-annotated
-with `@BeanOverride`, and instantiates the corresponding `BeanOverrideProcessor` which is
+The bean overriding infrastructure searches for annotations on test classes as well as
+annotations on non-static fields in test classes that are meta-annotated with
+`@BeanOverride` and instantiates the corresponding `BeanOverrideProcessor` which is
 responsible for creating an appropriate `BeanOverrideHandler`.

 The internal `BeanOverrideBeanFactoryPostProcessor` then uses bean override handlers to
@@ -19,6 +19,6 @@ meta-annotation. If a bootstrapper is not explicitly configured by using
 `WebTestContextBootstrapper` is used, depending on the presence of `@WebAppConfiguration`.

 Since the `TestContextBootstrapper` SPI is likely to change in the future (to accommodate
-new requirements), we strongly encourage implementors not to implement this interface
+new requirements), we strongly encourage implementers not to implement this interface
 directly but rather to extend `AbstractTestContextBootstrapper` or one of its concrete
 subclasses instead.
@@ -49,6 +49,7 @@ Kotlin::
 <1> Injecting the `ApplicationContext`.
 ======

+
 Similarly, if your test is configured to load a `WebApplicationContext`, you can inject
 the web application context into your test, as follows:

@@ -86,6 +87,7 @@ Kotlin::
 <2> Injecting the `WebApplicationContext`.
 ======

+
 Dependency injection by using `@Autowired` is provided by the
 `DependencyInjectionTestExecutionListener`, which is configured by default
 (see xref:testing/testcontext-framework/fixture-di.adoc[Dependency Injection of Test Fixtures]).
@@ -94,24 +96,22 @@ Dependency injection by using `@Autowired` is provided by the
 Test classes that use the TestContext framework do not need to extend any particular
 class or implement a specific interface to configure their application context. Instead,
 configuration is achieved by declaring the `@ContextConfiguration` annotation at the
-class level. If your test class does not explicitly declare component classes or resource
-locations, the configured `ContextLoader` determines how to load a context from _default_
-configuration classes or a _default_ location. In addition to component classes and
-context resource locations, an application context can also be configured through
-xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[context customizers]
-or xref:testing/testcontext-framework/ctx-management/initializers.adoc[context initializers].
+class level. If your test class does not explicitly declare application context resource
+locations or component classes, the configured `ContextLoader` determines how to load a
+context from a default location or default configuration classes. In addition to context
+resource locations and component classes, an application context can also be configured
+through application context initializers.

-The following sections explain how to use `@ContextConfiguration` and related annotations
-to configure a test `ApplicationContext` by using component classes (typically
-`@Configuration` classes), XML configuration files, Groovy scripts, context customizers,
-or context initializers. Alternatively, you can implement and configure your own custom
-`SmartContextLoader` for advanced use cases.
+The following sections explain how to use Spring's `@ContextConfiguration` annotation to
+configure a test `ApplicationContext` by using XML configuration files, Groovy scripts,
+component classes (typically `@Configuration` classes), or context initializers.
+Alternatively, you can implement and configure your own custom `SmartContextLoader` for
+advanced use cases.

-* xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[Context Configuration with Component Classes]
-* xref:testing/testcontext-framework/ctx-management/xml.adoc[Context Configuration with XML Resources]
+* xref:testing/testcontext-framework/ctx-management/xml.adoc[Context Configuration with XML resources]
 * xref:testing/testcontext-framework/ctx-management/groovy.adoc[Context Configuration with Groovy Scripts]
-* xref:testing/testcontext-framework/ctx-management/default-config.adoc[Default Context Configuration]
-* xref:testing/testcontext-framework/ctx-management/mixed-config.adoc[Mixing Component Classes, XML, and Groovy Scripts]
+* xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[Context Configuration with Component Classes]
+* xref:testing/testcontext-framework/ctx-management/mixed-config.adoc[Mixing XML, Groovy Scripts, and Component Classes]
 * xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[Context Configuration with Context Customizers]
 * xref:testing/testcontext-framework/ctx-management/initializers.adoc[Context Configuration with Context Initializers]
 * xref:testing/testcontext-framework/ctx-management/inheritance.adoc[Context Configuration Inheritance]
@@ -1,53 +0,0 @@
-[[testcontext-ctx-management-default-config]]
-= Default Context Configuration
-
-As explained in the sections on
-xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[component classes],
-xref:testing/testcontext-framework/ctx-management/xml.adoc[XML resources], and
-xref:testing/testcontext-framework/ctx-management/groovy.adoc[Groovy scripts], the
-TestContext framework will attempt to locate _default_ context configuration if you do
-not explicitly specify `@Configuration` classes, XML configuration files, or Groovy
-scripts from which the test's `ApplicationContext` should be loaded.
-
-However, due to a bug in the detection algorithm, default context configuration for a
-superclass or enclosing class is currently ignored if the type hierarchy or enclosing
-class hierarchy (for `@Nested` test classes) does not declare `@ContextConfiguration`.
-
-Beginning with Spring Framework 7.1, the TestContext framework will reliably detect
-**all** _default_ context configuration within a type hierarchy or enclosing class
-hierarchy above a given test class in such scenarios. Consequently, test suites may
-encounter issues after the upgrade to 7.1. For example, if a static nested
-`@Configuration` class in a superclass or enclosing class is ignored due to the
-aforementioned bug, after the bug has been fixed in 7.1 that `@Configuration` class will
-no longer be ignored, which may lead to unexpected beans in the resulting
-`ApplicationContext` our outright failures in tests.
-
-In the interim, the TestContext framework logs a warning whenever it encounters _default_
-context configuration that is currently ignored — for example, a `@Configuration` class
-or XML configuration file. The remainder of this section provides guidance on how to
-address such issues if you encounter warnings in your test suite.
-
-[TIP]
-====
-Annotating the affected subclass or `@Nested` class with `@ContextConfiguration` allows
-you to take matters into your own hands and specify which classes in the hierarchy are
-actually intended to contribute context configuration.
-====
-
-If you do not want static nested `@Configuration` classes to be processed, you can:
-
- Remove the `@Configuration` declaration.
- Apply `@ContextConfiguration` only where you actually want such classes to be processed.
- Move the static nested `@Configuration` classes to standalone top-level classes so that
-  they cannot be accidentally interpreted as _default_ configuration classes.
-
-Similarly, if you encounter issues with _default_ XML configuration files or Groovy
-scripts being detected and you do not want them to be processed, you can:
-
- Apply `@ContextConfiguration` only where you actually want such resources to be
-  processed.
- Rename the resource files to something that does not match the default naming
-  convention (such as `*-context.xml` for XML configuration) so that they cannot be
-  accidentally interpreted as _default_ configuration files.
- Move the affected resource files to a different package or filesystem location within
-  your project.
@@ -543,85 +543,3 @@ Kotlin::
 ----
 ======

-The following example demonstrates how to implement and register a custom
-`SystemPropertyOverrideActiveProfilesResolver` that allows the `spring.profiles.active`
-property (when configured as a JVM system property) to override profiles configured via
-`@ActiveProfiles`:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	// profiles resolved programmatically via a custom resolver that
-	// allows "spring.profiles.active" to override @ActiveProfiles
-	@ActiveProfiles(
-			resolver = SystemPropertyOverrideActiveProfilesResolver.class,
-			inheritProfiles = false)
-	class TransferServiceTest extends AbstractIntegrationTest {
-		// test body
-	}
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	// profiles resolved programmatically via a custom resolver that
-	// allows "spring.profiles.active" to override @ActiveProfiles
-	@ActiveProfiles(
-			resolver = SystemPropertyOverrideActiveProfilesResolver::class,
-			inheritProfiles = false)
-	class TransferServiceTest : AbstractIntegrationTest() {
-		// test body
-	}
----
-======
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary",fold="-imports"]
----
-	import org.springframework.core.env.AbstractEnvironment;
-	import org.springframework.test.context.support.DefaultActiveProfilesResolver;
-	import org.springframework.util.StringUtils;
-
-	public class SystemPropertyOverrideActiveProfilesResolver extends DefaultActiveProfilesResolver {
-
-		@Override
-		public String[] resolve(Class<?> testClass) {
-			String profiles = System.getProperty(AbstractEnvironment.ACTIVE_PROFILES_PROPERTY_NAME);
-			if (StringUtils.hasText(profiles)) {
-				return StringUtils.commaDelimitedListToStringArray(
-						StringUtils.trimAllWhitespace(profiles));
-			}
-			return super.resolve(testClass);
-		}
-	}
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary",fold="-imports"]
----
-	import org.springframework.core.env.AbstractEnvironment
-	import org.springframework.test.context.support.DefaultActiveProfilesResolver
-	import org.springframework.util.StringUtils
-
-	class SystemPropertyOverrideActiveProfilesResolver : DefaultActiveProfilesResolver() {
-
-		override fun resolve(testClass: Class<*>): Array<String> {
-			val profiles = System.getProperty(AbstractEnvironment.ACTIVE_PROFILES_PROPERTY_NAME)
-			if (StringUtils.hasText(profiles)) {
-				return StringUtils.commaDelimitedListToStringArray(
-					StringUtils.trimAllWhitespace(profiles)
-				)
-			}
-			return super.resolve(testClass)
-		}
-	}
----
-======
@@ -1,32 +1,33 @@
 [[testcontext-ctx-management-mixed-config]]
-= Mixing Component Classes, XML, and Groovy Scripts
+= Mixing XML, Groovy Scripts, and Component Classes

-It may sometimes be desirable to mix component classes (typically `@Configuration`
-classes), XML configuration files, or Groovy scripts to configure an `ApplicationContext`
-for your tests. For example, if you use XML configuration in production for legacy
-reasons, you may decide that you want to use `@Configuration` classes to configure
+It may sometimes be desirable to mix XML configuration files, Groovy scripts, and
+component classes (typically `@Configuration` classes) to configure an
+`ApplicationContext` for your tests. For example, if you use XML configuration in
+production, you may decide that you want to use `@Configuration` classes to configure
 specific Spring-managed components for your tests, or vice versa.

 Furthermore, some third-party frameworks (such as Spring Boot) provide first-class
 support for loading an `ApplicationContext` from different types of resources
-simultaneously (for example, `@Configuration` classes, XML configuration files, and
-Groovy scripts). The Spring Framework, historically, has not supported this for standard
-deployments. Consequently, most of the `SmartContextLoader` implementations that the
-Spring Framework delivers in the `spring-test` module support only one resource type for
-each test context. However, this does not mean that you cannot use a mixture of resource
-types. One exception to the general rule is that the `GenericGroovyXmlContextLoader` and
+simultaneously (for example, XML configuration files, Groovy scripts, and
+`@Configuration` classes). The Spring Framework, historically, has not supported this for
+standard deployments. Consequently, most of the `SmartContextLoader` implementations that
+the Spring Framework delivers in the `spring-test` module support only one resource type
+for each test context. However, this does not mean that you cannot use both. One
+exception to the general rule is that the `GenericGroovyXmlContextLoader` and
 `GenericGroovyXmlWebContextLoader` support both XML configuration files and Groovy
 scripts simultaneously. Furthermore, third-party frameworks may choose to support the
-declaration of both `classes` and `locations` through `@ContextConfiguration`, and, with
+declaration of both `locations` and `classes` through `@ContextConfiguration`, and, with
 the standard testing support in the TestContext framework, you have the following options.

-If you want to use `@Configuration` classes and resource locations (for example, XML or
-Groovy) to configure your tests, you must pick one as the entry point, and that one must
-import or include the other. For example, in a `@Configuration` class, you can use
-`@ImportResource` to import XML configuration files or Groovy scripts; whereas, in XML or
-Groovy scripts, you can include `@Configuration` classes by using component scanning or
-defining them as normal Spring beans. Note that this behavior is semantically equivalent
+If you want to use resource locations (for example, XML or Groovy) and `@Configuration`
+classes to configure your tests, you must pick one as the entry point, and that one must
+include or import the other. For example, in XML or Groovy scripts, you can include
+`@Configuration` classes by using component scanning or defining them as normal Spring
+beans, whereas, in a `@Configuration` class, you can use `@ImportResource` to import XML
+configuration files or Groovy scripts. Note that this behavior is semantically equivalent
 to how you configure your application in production: In production configuration, you
-define either a set of `@Configuration` classes or a set of XML or Groovy resource
-locations from which your production `ApplicationContext` is loaded, but you still have
-the freedom to import or include the other type of configuration.
+define either a set of XML or Groovy resource locations or a set of `@Configuration`
+classes from which your production `ApplicationContext` is loaded, but you still have the
+freedom to include or import the other type of configuration.
+
@@ -1,5 +1,5 @@
 [[testcontext-ctx-management-xml]]
-= Context Configuration with XML Resources
+= Context Configuration with XML resources

 To load an `ApplicationContext` for your tests by using XML configuration files, annotate
 your test class with `@ContextConfiguration` and configure the `locations` attribute with
@@ -179,10 +179,6 @@ If a specific parameter in a constructor for a JUnit Jupiter test class is of ty
 `ApplicationContext` (or a sub-type thereof) or is annotated or meta-annotated with
 `@Autowired`, `@Qualifier`, or `@Value`, Spring injects the value for that specific
 parameter with the corresponding bean or value from the test's `ApplicationContext`.
-Similarly, if a specific parameter is annotated with `@MockitoBean` or `@MockitoSpyBean`,
-Spring will inject a Mockito mock or spy, respectively &mdash; see
-xref:testing/annotations/integration-spring/annotation-mockitobean.adoc[`@MockitoBean` and `@MockitoSpyBean`]
-for details.

 Spring can also be configured to autowire all arguments for a test class constructor if
 the constructor is considered to be _autowirable_. A constructor is considered to be
@@ -400,10 +396,11 @@ recursively.
 ====
 As of Spring Framework 7.0, the `SpringExtension` uses a test-method scoped
 `ExtensionContext` within `@Nested` test class hierarchies by default. However, the
-`SpringExtension` can be configured to use a test-class scoped `ExtensionContext` — for
-example via `@SpringExtensionConfig` or the `spring.test.extension.context.scope` Spring
-property (see
-xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-springextensionconfig[`@SpringExtensionConfig`]).
+`SpringExtension` can be configured to use a test-class scoped `ExtensionContext`.
+
+See the documentation for
+xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-springextensionconfig[`@SpringExtensionConfig`]
+for details.
 ====

 [TIP]
@@ -580,8 +580,8 @@ Kotlin::
 [[webtestclient-stream]]
 ==== Streaming Responses

-To test potentially infinite streams such as `"text/event-stream"`,
-`"application/jsonl"` or `"application/x-ndjson"`, start by verifying the response status and headers, and then
+To test potentially infinite streams such as `"text/event-stream"` or
+`"application/x-ndjson"`, start by verifying the response status and headers, and then
 obtain a `FluxExchangeResult`:

 [tabs]
@@ -49,9 +49,10 @@ This strategy resolves the API version from a request. The WebFlux config provid
 options to resolve from a header, query parameter, media type parameter,
 or from the URL path. You can also use a custom `ApiVersionResolver`.

-The path resolver selects the version from a path segment specified by index, or
-raises `InvalidApiVersionException`, and therefore never results in `null` (no version)
-unless it is configured with a `Predicate<RequestPath>` to determine if a path is versioned.
+NOTE: The path resolver always resolves the version from the specified path segment, or
+raises `InvalidApiVersionException` otherwise, and therefore it cannot yield to other
+resolvers.
+



@@ -251,8 +251,7 @@ Kotlin::
 ======

 TIP: If you need to have a `LocalValidatorFactoryBean` injected somewhere, create a bean and
-mark it with `@Primary`, or mark the one declared in the MVC config with `@Fallback`, in
-order to avoid conflict.
+mark it with `@Primary` in order to avoid conflict with the one declared in the MVC config.


 [[webflux-config-content-negotiation]]
@@ -107,4 +107,7 @@ Kotlin::


 [[webflux-ann-initbinder-model-design]]
-NOTE: For more guidance on model design, please see xref:web/webflux/data-binding.adoc[Data Binding].
+== Model Design
+[.small]#xref:web/webmvc/mvc-controller/ann-initbinder.adoc#mvc-ann-initbinder-model-design[See equivalent in the Servlet stack]#
+
+include::partial$web/web-data-binding-model-design.adoc[]
@@ -1,36 +0,0 @@
-[[webflux-data-binding]]
-= Data Binding
-:page-section-summary-toc: 1
-
-[.small]#xref:web/webmvc/mvc-data-binding.adoc[See equivalent in the Servlet stack]#
-
-Data binding is a mechanism that binds string parameters onto an object graph with type conversion.
-It is a core mechanism of the Spring Framework that helps with application configuration.
-In web applications it makes it easy to access query parameters and form data through richly typed objects rather than through maps of string values.
-
-To learn more about the data binding mechanism, including constructor and setter binding, property name syntax, type conversion,
-and more, see xref:core/validation/data-binding.adoc[Data binding] in the Core Technologies section.
-
-For annotated controllers, data binding applies to a
-xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute] method argument.
-For functional endpoints, use the `bind` method of xref:web/webflux-functional.adoc#webflux-fn-request[ServerRequest].
-
-TIP: For browser applications with annotated controllers, you can use
-xref:web/webflux/controller/ann-modelattrib-methods.adoc[@ModelAttribute methods]
-to initialize additional model attributes for use in rendered views.
-
-Each request uses a separate `WebDataBinder` instance.
-For annotated controllers, this instance can be customized through
-xref:web/webflux/controller/ann-initbinder.adoc[@InitBinder methods] within a controller, or
-across controllers through xref:web/webmvc/mvc-controller/ann-advice.adoc[Controller Advice].
-For functional endpoints, use overloaded `ServerRequest.bind` methods.
-
-
-
-
-[[webflux-data-binding-design]]
-== Model Design
-[.small]#xref:web/webmvc/mvc-data-binding.adoc#mvc-data-binding-design[See equivalent in the Servlet stack]#
-
-include::partial$web/web-data-binding-model-design.adoc[]
-
@@ -485,8 +485,8 @@ The `JacksonJsonEncoder` works as follows:
 * 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
-`application/jsonl`, `application/x-ndjson` or `application/stream+x-jackson-smile`,
-encode, write, and flush each value individually using a
+`application/x-ndjson` or `application/stream+x-jackson-smile`, encode, write, and
+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
@@ -598,7 +598,7 @@ To configure all three in WebFlux, you'll need to supply a pre-configured instan
 [.small]#xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-http-streaming[See equivalent in the Servlet stack]#

 When streaming to the HTTP response (for example, `text/event-stream`,
-`application/jsonl`, `application/x-ndjson`), it is important to send data periodically, in order to
+`application/x-ndjson`), it is important to send data periodically, in order to
 reliably detect a disconnected client sooner rather than later. Such a send could be a
 comment-only, empty SSE event or any other "no-op" data that would effectively serve as
 a heartbeat.
@@ -49,9 +49,10 @@ This strategy resolves the API version from a request. The MVC config provides b
 options to resolve from a header, query parameter, media type parameter,
 or from the URL path. You can also use a custom `ApiVersionResolver`.

-The path resolver selects the version from a path segment specified by index, or
-raises `InvalidApiVersionException`, and therefore never results in `null` (no version)
-unless it is configured with a `Predicate<RequestPath>` to determine if a path is versioned.
+NOTE: The path resolver always resolves the version from the specified path segment, or
+raises `InvalidApiVersionException` otherwise, and therefore it cannot yield to other
+resolvers.
+



@@ -182,7 +182,7 @@ The parameters to any of the above macros have consistent meanings:
  For strictly sorted maps, you can use a `SortedMap` (such as a `TreeMap`) with a
  suitable `Comparator` and, for arbitrary Maps that should return values in insertion
  order, use a `LinkedHashMap` or a `LinkedMap` from `commons-collections`.
-* `separator`: Where multiple options are available as discrete elements (radio buttons
+* `separator`: Where multiple options are available as discreet elements (radio buttons
  or checkboxes), the sequence of characters used to separate each one in the list
  (such as `<br>`).
 * `attributes`: An additional string of arbitrary tags or text to be included within
@@ -23,17 +23,13 @@ For all converters, a default media type is used, but you can override it by set
 By default, this converter supports all text media types(`text/{asterisk}`) and writes with a `Content-Type` of `text/plain`.

 | `FormHttpMessageConverter`
-| An `HttpMessageConverter` implementation that can read and write URL encoded forms.
+| An `HttpMessageConverter` implementation that can read and write form data from the HTTP request and response.
 By default, this converter reads and writes the `application/x-www-form-urlencoded` media type.
 Form data is read from and written into a `MultiValueMap<String, String>`.
-`Map<String, String>` is also supported, but multiple values under the same key will be ignored.
-
-| `MultipartHttpMessageConverter`
-| An `HttpMessageConverter` implementation that can read and write multipart messages.
-`MultiValueMap<String, Object>` can be written to multipart messages, converting each part independently using
-the configured message converters. Multipart messages can be read into `MultiValueMap<String, Part>`, each value
-being a `Part` or one of its subtypes (`FormFieldPart` and `FilePart`).
-By default, `multipart/form-data` is supported. Additional multipart subtypes can be supported for writing form data.
+The converter can also write (but not read) multipart data read from a `MultiValueMap<String, Object>`.
+By default, `multipart/form-data` is supported.
+Additional multipart subtypes can be supported for writing form data.
+Consult the javadoc for `FormHttpMessageConverter` for further details.

 | `ByteArrayHttpMessageConverter`
 | An `HttpMessageConverter` implementation that can read and write byte arrays from the HTTP request and response.
@@ -423,8 +423,8 @@ 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).
-* A multi-value stream with a streaming media type (such as `application/jsonl`,
-`application/x-ndjson` or `text/event-stream`) is adapted to, similar to using `ResponseBodyEmitter` or
+* 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).
 Applications can also return `Flux<ServerSentEvent>` or `Observable<ServerSentEvent>`.
 * A multi-value stream with any other media type (such as `application/json`) is adapted
@@ -19,5 +19,4 @@ example shows:
 include-code::./MyController[tag=snippet,indent=0]

 TIP: If you need to have a `LocalValidatorFactoryBean` injected somewhere, create a bean and
-mark it with `@Primary`, or mark the one declared in the MVC configuration with
-`@Fallback`, in order to avoid conflict.
+mark it with `@Primary` in order to avoid conflict with the one declared in the MVC configuration.
@@ -188,7 +188,7 @@ the content negotiation during the error handling phase will decide which conten
 | `View`
 | A `View` instance to use for rendering together with the implicit model -- determined
  through command objects and `@ModelAttribute` methods. The handler method may also
-  programmatically enrich the model by declaring a `Model` argument (described earlier).
+  programmatically enrich the model by declaring a `Model` argument (descried earlier).

 | `java.util.Map`, `org.springframework.ui.Model`
 | Attributes to be added to the implicit model with the view name implicitly determined
@@ -107,4 +107,7 @@ Kotlin::


 [[mvc-ann-initbinder-model-design]]
-NOTE: For more guidance on model design, please see xref:web/webmvc/mvc-data-binding.adoc[Data Binding].
+== Model Design
+[.small]#xref:web/webflux/controller/ann-initbinder.adoc#webflux-ann-initbinder-model-design[See equivalent in the Reactive stack]#
+
+include::partial$web/web-data-binding-model-design.adoc[]
@@ -1,34 +0,0 @@
-[[mvc-data-binding]]
-= Data Binding
-:page-section-summary-toc: 1
-
-[.small]#xref:web/webflux/data-binding.adoc[See equivalent in the Reactive stack]#
-
-Data binding is a mechanism that binds string parameters onto an object graph with type conversion.
-It is a core mechanism of the Spring Framework that helps with application configuration.
-In web applications it makes it easy to access query parameters and form data through richly typed objects rather than through maps of string values.
-
-To learn more about the data binding mechanism, including constructor and setter binding, property name syntax, type conversion,
-and more, see xref:core/validation/data-binding.adoc[Data binding] in the Core Technologies section.
-
-For annotated controllers, data binding applies to a
-xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute] method argument.
-For functional endpoints, use the `bind` method of xref:web/webmvc-functional.adoc#webmvc-fn-request[ServerRequest].
-
-TIP: For browser applications with annotated controllers, you can use
-xref:web/webmvc/mvc-controller/ann-modelattrib-methods.adoc[@ModelAttribute methods]
-to initialize additional model attributes for use in rendered views.
-
-Each request uses a separate `WebDataBinder` instance.
-For annotated controllers, this instance can be customized through
-xref:web/webmvc/mvc-controller/ann-initbinder.adoc[@InitBinder methods] within a controller, or
-across controllers through xref:web/webmvc/mvc-controller/ann-advice.adoc[Controller Advice].
-For functional endpoints, use overloaded `ServerRequest.bind` methods.
-
-
-
-[[mvc-data-binding-design]]
-== Model Design
-[.small]#xref:web/webflux/data-binding.adoc#webflux-data-binding-design[See equivalent in the Reactive stack]#
-
-include::partial$web/web-data-binding-model-design.adoc[]
@@ -3,7 +3,7 @@

 [.small]#xref:web/webflux/uri-building.adoc[See equivalent in the Reactive stack]#

-This section describes various options available in the Spring Framework to work with URIs.
+This section describes various options available in the Spring Framework to work with URI's.

 include::partial$web/web-uris.adoc[leveloffset=+1]

@@ -257,7 +257,7 @@ An `XhrTransport`, by definition, supports both `xhr-streaming` and `xhr-polling
 from a client perspective, there is no difference other than in the URL used to connect
 to the server. At present there are two implementations:

-* `RestClientXhrTransport` uses Spring's `RestClient` for HTTP requests.
+* `RestTemplateXhrTransport` uses Spring's `RestTemplate` for HTTP requests.
 * `JettyXhrTransport` uses Jetty's `HttpClient` for HTTP requests.

 The following example shows how to create a SockJS client and connect to a SockJS endpoint:
@@ -266,7 +266,7 @@ The following example shows how to create a SockJS client and connect to a SockJ
 ----
  List<Transport> transports = new ArrayList<>(2);
  transports.add(new WebSocketTransport(new StandardWebSocketClient()));
-  transports.add(new RestClientXhrTransport());
+  transports.add(new RestTemplateXhrTransport());

  SockJsClient sockJsClient = new SockJsClient(transports);
  sockJsClient.doHandshake(new MyWebSocketHandler(), "ws://example.com:8080/sockjs");
@@ -1,53 +1,91 @@
-Data binding involves binding untrusted input onto application objects.
-For security reasons, it's crucial to ensure that input is properly constrained to expected fields only.
-This section provides guidance for safe binding.
+xref:core/validation/data-binding.adoc[Data binding] for web requests involves
+binding request parameters to a model object. By default, request parameters can be bound
+to any public property of the model object, which means malicious clients can provide
+extra values for properties that exist in the model object graph, but are not expected to
+be set. This is why model object design requires careful consideration.

-First, prefer **immutable object design** for web binding purposes.
-It is safe because a constructor naturally constrains binding to expected inputs.
-You can use a Java record or a class with a primary constructor, and either can have further nested objects.
-See xref:core/validation/data-binding.adoc#data-binding-constructor-binding[Constructor Binding] for details.
+TIP: The model object, and its nested object graph is also sometimes referred to as a
+_command object_, _form-backing object_, or _POJO_ (Plain Old Java Object).

-Another option for safe binding is to use **dedicated objects** designed for the expected input.
-Such objects, even if mutable, are safe because they constrain binding to the expected inputs.
+A good practice is to use a _dedicated model object_ rather than exposing your domain
+model such as JPA or Hibernate entities for web data binding. For example, on a form to
+change an email address, create a `ChangeEmailForm` model object that declares only
+the properties required for the input:

-Domain objects such as JPA or Hibernate entities are generally not safe for web binding
-as they likely contain more properties than the expected inputs.
-For such cases, it's crucial to declare the properties to expose for binding.
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	public class ChangeEmailForm {
+
+		private String oldEmailAddress;
+		private String newEmailAddress;
+
+		public void setOldEmailAddress(String oldEmailAddress) {
+			this.oldEmailAddress = oldEmailAddress;
+		}
+
+		public String getOldEmailAddress() {
+			return this.oldEmailAddress;
+		}
+
+		public void setNewEmailAddress(String newEmailAddress) {
+			this.newEmailAddress = newEmailAddress;
+		}
+
+		public String getNewEmailAddress() {
+			return this.newEmailAddress;
+		}
+
+	}
+----
+
+Another good practice is to apply
+xref:core/validation/data-binding.adoc#data-binding-constructor-binding[constructor binding],
+which uses only the request parameters it needs for constructor arguments, and any other
+input is ignored. This is in contrast to property binding which by default binds every
+request parameter for which there is a matching property.
+
+If neither a dedicated model object nor constructor binding is sufficient, and you must
+use property binding, we strongly recommend registering `allowedFields` patterns (case
+sensitive) on `WebDataBinder` in order to prevent unexpected properties from being set.
 For example:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	@Controller
-	public class PersonController {
+	public class ChangeEmailController {

 		@InitBinder
 		void initBinder(WebDataBinder binder) {
-			// See Javadoc for supported pattern syntax
-			binder.setAllowedFields("firstName", "lastName", "*Address");
+			binder.setAllowedFields("oldEmailAddress", "newEmailAddress");
 		}
+
+		// @RequestMapping methods, etc.
+
 	}
 ----

-NOTE: It is also possible to configure `disallowedFields`, but that's fragile, and
-due to be https://github.com/spring-projects/spring-framework/issues/36802[deprecated] in Spring Framework 7.1.
-It is easy to overlook fields or introduce additional fields over time that should also be excluded.
+You can also register `disallowedFields`  patterns (case insensitive). However,
+"allowed" configuration is preferred over "disallowed" as it is more explicit and less
+prone to mistakes.

-By default, `DataBinder` applies both constructor and setter binding.
-This is fine with immutable objects and dedicated objects, but for domain objects, you must
-remember to set `allowedFields`. To ensure data binding is only used in declarative style where
-expected inputs are explicitly declared, you can set  `declarativeBinding` on `DataBinder`.
-That applies constructor binding always, and setter binding conditionally if `allowedFields` is set.
-The following shows how to set this flag globally, or
-you can also narrow it through attributes on `ControllerAdvice`:
+By default, constructor and property binding are both used. If you want to use
+constructor binding only, you can set the `declarativeBinding` flag on `WebDataBinder`
+through an `@InitBinder` method either locally within a controller or globally through an
+`@ControllerAdvice`. Turning this flag on ensures that only constructor binding is used
+and that property binding is not used unless `allowedFields` patterns are configured.
+For example:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	@ControllerAdvice
-	public class ControllerConfig {
+	@Controller
+	public class MyController {

 		@InitBinder
 		void initBinder(WebDataBinder binder) {
 			binder.setDeclarativeBinding(true);
 		}
+
+		// @RequestMapping methods, etc.
+
 	}
 ----
@@ -2,7 +2,7 @@
 = UriComponents
 [.small]#Spring MVC and Spring WebFlux#

-`UriComponentsBuilder` helps to build URIs from URI templates with variables, as the following example shows:
+`UriComponentsBuilder` helps to build URI's from URI templates with variables, as the following example shows:

 [tabs]
 ======
@@ -128,7 +128,7 @@ Kotlin::
 = UriBuilder
 [.small]#Spring MVC and Spring WebFlux#

-<<uricomponents, `UriComponentsBuilder`>> implements `UriBuilder`. You can create a
+<<web-uricomponents, `UriComponentsBuilder`>> implements `UriBuilder`. You can create a
 `UriBuilder`, in turn, with a `UriBuilderFactory`. Together, `UriBuilderFactory` and
 `UriBuilder` provide a pluggable mechanism to build URIs from URI templates, based on
 shared configuration, such as a base URL, encoding preferences, and other details.
@@ -247,7 +247,7 @@ and treats deviations from the syntax as illegal.
 https://github.com/web-platform-tests/wpt/tree/master/url[URL parsing algorithm] in the
 https://url.spec.whatwg.org[WhatWG URL Living standard]. It provides lenient handling of
 a wide range of cases of unexpected input. Browsers implement this in order to handle
-leniently user typed URLs. For more details, see the URL Living Standard and URL parsing
+leniently user typed URL's. For more details, see the URL Living Standard and URL parsing
 https://github.com/web-platform-tests/wpt/tree/master/url[test cases].

 By default, `RestClient`, `WebClient`, and `RestTemplate` use the RFC parser type, and
@@ -255,10 +255,10 @@ expect applications to provide with URL templates that conform to RFC syntax. To
 that you can customize the `UriBuilderFactory` on any of the clients.

 Applications and frameworks may further rely on `UriComponentsBuilder` for their own needs
-to parse user provided URLs in order to inspect and possibly validated URI components
+to parse user provided URL's in order to inspect and possibly validated URI components
 such as the scheme, host, port, path, and query. Such components can decide to use the
-WhatWG parser type in order to handle URLs more leniently, and to align with the way
-browsers parse URIs, in case of a redirect to the input URL or if it is included in a
+WhatWG parser type in order to handle URL's more leniently, and to align with the way
+browsers parse URI's, in case of a redirect to the input URL or if it is included in a
 response to a browser.


@@ -373,14 +373,14 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	String baseUrl = "https://example.com";
-	DefaultUriBuilderFactory factory = new DefaultUriBuilderFactory(baseUrl);
+	DefaultUriBuilderFactory factory = new DefaultUriBuilderFactory(baseUrl)
 	factory.setEncodingMode(EncodingMode.TEMPLATE_AND_VALUES);

-	// Customize the RestTemplate.
+	// Customize the RestTemplate..
 	RestTemplate restTemplate = new RestTemplate();
 	restTemplate.setUriTemplateHandler(factory);

-	// Customize the WebClient.
+	// Customize the WebClient..
 	WebClient client = WebClient.builder().uriBuilderFactory(factory).build();
 ----

@@ -393,12 +393,12 @@ Kotlin::
 		encodingMode = EncodingMode.TEMPLATE_AND_VALUES
 	}

-	// Customize the RestTemplate.
+	// Customize the RestTemplate..
 	val restTemplate = RestTemplate().apply {
 		uriTemplateHandler = factory
 	}

-	// Customize the WebClient.
+	// Customize the WebClient..
 	val client = WebClient.builder().uriBuilderFactory(factory).build()
 ----
 ======
@@ -1,11 +1,11 @@
 {
  "dependencies": {
-    "antora": "3.2.0-alpha.12",
+    "antora": "3.2.0-alpha.11",
    "@antora/atlas-extension": "1.0.0-alpha.5",
-    "@antora/collector-extension": "1.0.3",
+    "@antora/collector-extension": "1.0.2",
    "@asciidoctor/tabs": "1.0.0-beta.6",
-    "@springio/antora-extensions": "1.14.12",
-    "fast-xml-parser": "5.7.0",
-    "@springio/asciidoctor-extensions": "1.0.0-alpha.18"
+    "@springio/antora-extensions": "1.14.7",
+    "fast-xml-parser": "5.3.4",
+    "@springio/asciidoctor-extensions": "1.0.0-alpha.17"
  }
 }
@@ -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.docs.core.expressions.languageref.expressionsoperatorsoverloaded;
-
-import org.springframework.expression.Operation;
-import org.springframework.expression.OperatorOverloader;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class ListConcatenation implements OperatorOverloader {
-
-	@Override
-	public boolean overridesOperation(Operation operation, Object left, Object right) {
-		return (operation == Operation.ADD && left instanceof List && right instanceof List);
-	}
-
-	@Override
-	@SuppressWarnings({"rawtypes", "unchecked"})
-	public Object operate(Operation operation, Object left, Object right) {
-		if (operation == Operation.ADD &&
-				left instanceof List list1 && right instanceof List list2) {
-
-			List result = new ArrayList(list1);
-			result.addAll(list2);
-			return result;
-		}
-		throw new UnsupportedOperationException(
-				"No overload for operation %s and operands [%s] and [%s]"
-						.formatted(operation, left, right));
-	}
-
-}
@@ -1,42 +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.docs.dataaccess.transaction.declarative.transactiondeclarativeannotations;
-
-import javax.sql.DataSource;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.jdbc.datasource.DataSourceTransactionManager;
-import org.springframework.transaction.PlatformTransactionManager;
-import org.springframework.transaction.annotation.EnableTransactionManagement;
-
-// tag::snippet[]
-@Configuration
-@EnableTransactionManagement
-public class AppConfig {
-
-	@Bean
-	public FooService fooService() {
-		return new DefaultFooService();
-	}
-
-	@Bean
-	public PlatformTransactionManager txManager(DataSource dataSource) {
-		return new DataSourceTransactionManager(dataSource);
-	}
-}
-// end::snippet[]
@@ -1,20 +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.docs.dataaccess.transaction.declarative.transactiondeclarativeannotations;
-
-public class DefaultFooService implements FooService {
-}
@@ -1,20 +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.docs.dataaccess.transaction.declarative.transactiondeclarativeannotations;
-
-public interface FooService {
-}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2024 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2024 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2024 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.
@@ -21,6 +21,7 @@ import org.springframework.test.web.servlet.assertj.MockMvcTester;
 import org.springframework.test.web.servlet.assertj.MvcTestResult;

 import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;

 /**
 * @author Stephane Nicoll
@@ -1,54 +0,0 @@
-/*
- * Copyright 2025-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.docs.testing.resttestclient.multipart;
-
-import org.junit.jupiter.api.Test;
-
-import org.springframework.core.ParameterizedTypeReference;
-import org.springframework.http.MediaType;
-import org.springframework.http.converter.multipart.FilePart;
-import org.springframework.http.converter.multipart.FormFieldPart;
-import org.springframework.http.converter.multipart.Part;
-import org.springframework.test.web.servlet.client.RestTestClient;
-import org.springframework.util.MultiValueMap;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class MultipartTests {
-
-	RestTestClient client;
-
-	@Test
-	void multipart() {
-		// tag::multipart[]
-		client.get().uri("/upload")
-				.accept(MediaType.MULTIPART_FORM_DATA)
-				.exchange()
-				.expectStatus().isOk()
-				.expectBody(new ParameterizedTypeReference<MultiValueMap<String, Part>>() {})
-				.value(result -> {
-					Part field = result.getFirst("fieldPart");
-					assertThat(field).isInstanceOfSatisfying(FormFieldPart.class,
-							formField -> assertThat(formField.value()).isEqualTo("fieldValue"));
-					Part file = result.getFirst("filePart");
-					assertThat(file).isInstanceOfSatisfying(FilePart.class,
-							filePart -> assertThat(filePart.filename()).isEqualTo("logo.png"));
-				});
-		// end::multipart[]
-	}
-
-}
@@ -29,7 +29,7 @@ public class ExceptionController {

 	// tag::narrow[]
 	@ExceptionHandler({FileSystemException.class, RemoteException.class})
-	public ResponseEntity<String> handleIOException(IOException ex) {
+	public ResponseEntity<String> handleIoException(IOException ex) {
 		return ResponseEntity.internalServerError().body(ex.getMessage());
 	}
 	// end::narrow[]
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -17,7 +17,9 @@
 package org.springframework.docs.web.websocket.stomp.websocketstompconfigurationperformance;

 import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
 import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
+import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
 import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
 import org.springframework.web.socket.config.annotation.WebSocketTransportRegistration;

@@ -17,7 +17,9 @@
 package org.springframework.docs.web.websocket.stomp.websocketstompconfigurationperformance;

 import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
 import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
+import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
 import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
 import org.springframework.web.socket.config.annotation.WebSocketTransportRegistration;

@@ -22,6 +22,7 @@ import org.springframework.context.annotation.Lazy;
 import org.springframework.messaging.simp.config.MessageBrokerRegistry;
 import org.springframework.scheduling.TaskScheduler;
 import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
+import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
 import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

 // tag::snippet[]
@@ -19,8 +19,13 @@ package org.springframework.docs.web.websocket.stomp.websocketstompmessageflow;
 import java.text.SimpleDateFormat;
 import java.util.Date;

+import org.springframework.context.annotation.Configuration;
 import org.springframework.messaging.handler.annotation.MessageMapping;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
 import org.springframework.stereotype.Controller;
+import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
+import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
+import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

 // tag::snippet[]
@Controller
@@ -17,6 +17,7 @@
 package org.springframework.docs.web.websocket.stomp.websocketstomporderedmessages;

 import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
 import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
 import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
 import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
@@ -54,6 +54,6 @@ class ConcurrentOperationExecutor : Ordered {
 				lockFailureException = ex
 			}
 		} while (numAttempts <= this.maxRetries)
-		throw lockFailureException
+		throw lockFailureException!!
 	}
 } // end::snippet[]
@@ -1,37 +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.docs.core.expressions.languageref.expressionsoperatorsoverloaded
-
-import org.springframework.expression.Operation
-import org.springframework.expression.OperatorOverloader
-
-class ListConcatenation: OperatorOverloader {
-
-	override fun overridesOperation(operation: Operation, left: Any?, right: Any?): Boolean {
-		return operation == Operation.ADD && left is List<*> && right is List<*>
-	}
-
-	override fun operate(operation: Operation, left: Any?, right: Any?): Any {
-		if (operation == Operation.ADD && left is List<*> && right is List<*>) {
-			return left + right
-		}
-
-		throw UnsupportedOperationException(
-			"No overload for operation $operation and operands [$left] and [$right]")
-	}
-
-}
@@ -1,41 +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.docs.dataaccess.transaction.declarative.transactiondeclarativeannotations
-
-import org.springframework.context.annotation.Bean
-import org.springframework.context.annotation.Configuration
-import org.springframework.jdbc.datasource.DataSourceTransactionManager
-import org.springframework.transaction.PlatformTransactionManager
-import org.springframework.transaction.annotation.EnableTransactionManagement
-import javax.sql.DataSource
-
-// tag::snippet[]
-@Configuration
-@EnableTransactionManagement
-class AppConfig {
-
-	@Bean
-	fun fooService(): FooService {
-		return DefaultFooService()
-	}
-
-	@Bean
-	fun txManager(dataSource: DataSource): PlatformTransactionManager {
-		return DataSourceTransactionManager(dataSource)
-	}
-}
-// end::snippet[]
@@ -1,20 +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.docs.dataaccess.transaction.declarative.transactiondeclarativeannotations
-
-class DefaultFooService : FooService {
-}
@@ -1,20 +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.docs.dataaccess.transaction.declarative.transactiondeclarativeannotations
-
-interface FooService {
-}
@@ -16,9 +16,12 @@

 package org.springframework.docs.testing.mockmvc.assertj.mockmvctesterintegration

+import org.assertj.core.api.Assertions
 import org.assertj.core.api.Assertions.*
 import org.springframework.test.web.servlet.assertj.MockMvcTester
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers
 import org.springframework.test.web.servlet.result.MockMvcResultMatchers.*

 /**
@@ -27,7 +27,7 @@ class ExceptionController {

 	// tag::narrow[]
 	@ExceptionHandler(FileSystemException::class, RemoteException::class)
-	fun handleIOException(ex: IOException): ResponseEntity<String> {
+	fun handleIoException(ex: IOException): ResponseEntity<String> {
 		return ResponseEntity.internalServerError().body(ex.message)
 	}
 	// end::narrow[]
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-present the original author or authors.
+ * Copyright 2002-2025 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.
--- a/Show More
+++ b/Show More