Release v6.1.2

2026-06-08 17:33:33 +00:00 · 2023-12-14 10:28:53 +00:00
2292 changed files with 23351 additions and 33221 deletions
@@ -1,3 +1,3 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
-java=17.0.10-librca
+java=17.0.8.1-librca
@@ -1,4 +1,4 @@
-# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-6.1.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.1.x?groups=Build") [![Revved up by Develocity](https://img.shields.io/badge/Revved%20up%20by-Develocity-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
+# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-6.1.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.1.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)

 This is the home of the Spring Framework: the foundation for all [Spring projects](https://spring.io/projects). Collectively the Spring Framework and the family of Spring projects are often referred to simply as "Spring". 

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

 ## Stay in Touch

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

 ## License

@@ -4,7 +4,7 @@ plugins {
 	id 'org.jetbrains.kotlin.plugin.serialization' version "${kotlinVersion}" apply false
 	id 'org.jetbrains.dokka' version '1.8.20'
 	id 'org.unbroken-dome.xjc' version '2.0.0' apply false
-	id 'com.github.ben-manes.versions' version '0.51.0'
+	id 'com.github.ben-manes.versions' version '0.49.0'
 	id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
 	id 'de.undercouch.download' version '5.4.0'
 	id 'me.champeau.jmh' version '0.7.2' apply false
@@ -104,7 +104,7 @@ configure([rootProject] + javaProjects) { project ->
 			// TODO Uncomment link to JUnit 5 docs once we execute Gradle with Java 18+.
 			// See https://github.com/spring-projects/spring-framework/issues/27497
 			//
-			// "https://junit.org/junit5/docs/5.10.2/api/",
+			// "https://junit.org/junit5/docs/5.10.1/api/",
 			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			//"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
 			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
@@ -1,2 +1,2 @@
 org.gradle.caching=true
-javaFormatVersion=0.0.41
+javaFormatVersion=0.0.39
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -50,12 +50,12 @@ 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("10.14.1");
+			checkstyle.setToolVersion("10.12.5");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
 			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
-			checkstyleDependencies.add(
-					project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
+			checkstyleDependencies
+				.add(project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
 		});
 	}

@@ -2,7 +2,7 @@

 The Spring Framework uses https://concourse-ci.org/[Concourse] for its CI build and other automated tasks.
 The Spring team has a dedicated Concourse instance available at https://ci.spring.io with a build pipeline
-for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.1.x[Spring Framework 6.1.x].
+for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x[Spring Framework 6.0.x].

 === Setting up your development environment

@@ -51,7 +51,7 @@ The pipeline can be deployed using the following command:

 [source]
 ----
-$ fly -t spring set-pipeline -p spring-framework-6.1.x -c ci/pipeline.yml -l ci/parameters.yml
+$ fly -t spring set-pipeline -p spring-framework-6.0.x -c ci/pipeline.yml -l ci/parameters.yml
 ----

 NOTE: This assumes that you have credhub integration configured with the appropriate secrets.
@@ -1,4 +1,4 @@
-FROM ubuntu:jammy-20240125
+FROM ubuntu:jammy-20231128

 ADD setup.sh /setup.sh
 ADD get-jdk-url.sh /get-jdk-url.sh
@@ -7,6 +7,6 @@ RUN ./setup.sh
 ENV JAVA_HOME /opt/openjdk/java17
 ENV JDK17 /opt/openjdk/java17
 ENV JDK21 /opt/openjdk/java21
-ENV JDK23 /opt/openjdk/java23
+ENV JDK22 /opt/openjdk/java22

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

 case "$1" in
 	java17)
-		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.10%2B13/bellsoft-jdk17.0.10+13-linux-amd64.tar.gz"
+		echo "https://download.bell-sw.com/java/17.0.9+11/bellsoft-jdk17.0.9+11-linux-amd64.tar.gz"
 	;;
 	java21)
-		echo "https://github.com/bell-sw/Liberica/releases/download/21.0.2%2B14/bellsoft-jdk21.0.2+14-linux-amd64.tar.gz"
+		echo "https://download.bell-sw.com/java/21.0.1+12/bellsoft-jdk21.0.1+12-linux-amd64.tar.gz"
 	;;
-	java23)
-		echo "https://download.java.net/java/early_access/jdk23/10/GPL/openjdk-23-ea+10_linux-x64_bin.tar.gz"
+	java22)
+		echo "https://download.java.net/java/early_access/jdk22/27/GPL/openjdk-22-ea+27_linux-x64_bin.tar.gz"
 	;;
 	*)
 		echo $"Unknown java version"
@@ -3,7 +3,7 @@ github-repo-name: "spring-projects/spring-framework"
 sonatype-staging-profile: "org.springframework"
 docker-hub-organization: "springci"
 artifactory-server: "https://repo.spring.io"
-branch: "6.1.x"
+branch: "main"
 milestone: "6.1.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
@@ -121,14 +121,14 @@ resources:
    access_token: ((github-ci-status-token))
    branch: ((branch))
    context: jdk21-build
- name: repo-status-jdk23-build
+- name: repo-status-jdk22-build
  type: github-status-resource
  icon: eye-check-outline
  source:
    repository: ((github-repo-name))
    access_token: ((github-ci-status-token))
    branch: ((branch))
-    context: jdk23-build
+    context: jdk22-build
 - name: slack-alert
  type: slack-notification
  icon: slack
@@ -249,15 +249,13 @@ jobs:
              <<: *slack-fail-params
    - put: repo-status-jdk21-build
      params: { state: "success", commit: "git-repo" }
- name: jdk23-build
+- name: jdk22-build
  serial: true
  public: true
  plan:
    - get: ci-image
    - get: git-repo
-    - get: every-morning
-      trigger: false
-    - put: repo-status-jdk23-build
+    - put: repo-status-jdk22-build
      params: { state: "pending", commit: "git-repo" }
    - do:
        - task: check-project
@@ -266,16 +264,16 @@ jobs:
          privileged: true
          timeout: ((task-timeout))
          params:
-            TEST_TOOLCHAIN: 23
+            TEST_TOOLCHAIN: 22
            <<: *build-project-task-params
      on_failure:
        do:
-          - put: repo-status-jdk23-build
+          - put: repo-status-jdk22-build
            params: { state: "failure", commit: "git-repo" }
          - put: slack-alert
            params:
              <<: *slack-fail-params
-    - put: repo-status-jdk23-build
+    - put: repo-status-jdk22-build
      params: { state: "success", commit: "git-repo" }
 - name: stage-milestone
  serial: true
@@ -428,7 +426,7 @@ jobs:

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

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

 pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21,JDK23 \
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check antora
 popd > /dev/null
@@ -28,7 +28,7 @@ javadoc {
 		header = rootProject.description
 		use = true
 		overview = project.relativePath("$rootProject.rootDir/framework-docs/src/docs/api/overview.html")
-		destinationDir = file("$project.docsDir/javadoc-api")
+		destinationDir = file("${project.buildDir}/docs/javadoc-api")
 		splitIndex = true
 		links(rootProject.ext.javadocLinks)
 		addBooleanOption('Xdoclint:syntax,reference', true) // only check syntax and reference with doclint
@@ -52,7 +52,7 @@ rootProject.tasks.dokkaHtmlMultiModule.configure {
 		tasks.named("javadoc")
 	}
 	moduleName.set("spring-framework")
-	outputDirectory.set(file("$docsDir/kdoc-api"))
+	outputDirectory.set(project.file("$buildDir/docs/kdoc-api"))
 	includes.from("$rootProject.rootDir/framework-docs/src/docs/api/dokka-overview.md")
 }

@@ -18,7 +18,6 @@ asciidoc:
    # FIXME: The package is not renamed
    chomp: 'all'
    fold: 'all'
-    table-stripes: 'odd'
    include-java: 'example$docs-src/main/java/org/springframework/docs'
    spring-site: 'https://spring.io'
    spring-site-blog: '{spring-site}/blog'
@@ -28,8 +28,8 @@ antora {
 			'@antora/atlas-extension': '1.0.0-alpha.1',
 			'@antora/collector-extension': '1.0.0-alpha.3',
 			'@asciidoctor/tabs': '1.0.0-beta.3',
-			'@opendevise/antora-release-line-extension': '1.0.0',
-			'@springio/antora-extensions': '1.8.2',
+			'@opendevise/antora-release-line-extension': '1.0.0-alpha.2',
+			'@springio/antora-extensions': '1.3.0',
 			'@springio/asciidoctor-extensions': '1.0.0-alpha.9'
 	]
 }
@@ -39,8 +39,8 @@
 ** xref:core/resources.adoc[]
 ** xref:core/validation.adoc[]
 *** xref:core/validation/validator.adoc[]
-*** xref:core/validation/beans-beans.adoc[]
 *** xref:core/validation/conversion.adoc[]
+*** xref:core/validation/beans-beans.adoc[]
 *** xref:core/validation/convert.adoc[]
 *** xref:core/validation/format.adoc[]
 *** xref:core/validation/format-configuring-formatting-globaldatetimeformat.adoc[]
@@ -421,7 +421,7 @@
 *** xref:integration/cache/specific-config.adoc[]
 ** xref:integration/observability.adoc[]
 ** xref:integration/checkpoint-restore.adoc[]
-** xref:integration/cds.adoc[]
+** xref:integration/class-data-sharing.adoc[]
 ** xref:integration/appendix.adoc[]
 * xref:languages.adoc[]
 ** xref:languages/kotlin.adoc[]
@@ -439,5 +439,4 @@
 ** xref:languages/groovy.adoc[]
 ** xref:languages/dynamic.adoc[]
 * xref:appendix.adoc[]
-* {spring-framework-wiki}[Wiki]
-
+* {spring-framework-wiki}[Wiki]
@@ -19,53 +19,15 @@ of the classpath -- for example, deployed within the application's JAR file.
 The following table lists all currently supported Spring properties.

 .Supported Spring Properties
-[cols="1,1"]
 |===
 | Name | Description

-| `spring.aot.enabled`
-| Indicates the application should run with AOT generated artifacts. See
-xref:core/aot.adoc[Ahead of Time Optimizations] and 
-{spring-framework-api}++/aot/AotDetector.html#AOT_ENABLED++[`AotDetector`]
-for details.
-
 | `spring.beaninfo.ignore`
 | Instructs Spring to use the `Introspector.IGNORE_ALL_BEANINFO` mode when calling the
 JavaBeans `Introspector`. See
 {spring-framework-api}++/beans/StandardBeanInfoFactory.html#IGNORE_BEANINFO_PROPERTY_NAME++[`CachedIntrospectionResults`]
 for details.

-| `spring.cache.reactivestreams.ignore`
-| Instructs Spring's caching infrastructure to ignore the presence of Reactive Streams,
-in particular Reactor's `Mono`/`Flux` in `@Cacheable` method return type declarations. See
-{spring-framework-api}++/cache/interceptor/CacheAspectSupport.html#IGNORE_REACTIVESTREAMS_PROPERTY_NAME++[`CacheAspectSupport`]
-for details.
-
-| `spring.classformat.ignore`
-| Instructs Spring to ignore class format exceptions during classpath scanning, in
-particular for unsupported class file versions. See
-{spring-framework-api}++/context/annotation/ClassPathScanningCandidateComponentProvider.html#IGNORE_CLASSFORMAT_PROPERTY_NAME++[`ClassPathScanningCandidateComponentProvider`]
-for details.
-
-| `spring.context.checkpoint`
-| Property that specifies a common context checkpoint. See
-xref:integration/checkpoint-restore.adoc#_automatic_checkpointrestore_at_startup[Automatic
-checkpoint/restore at startup] and
-{spring-framework-api}++/context/support/DefaultLifecycleProcessor.html#CHECKPOINT_PROPERTY_NAME++[`DefaultLifecycleProcessor`]
-for details.
-
-| `spring.context.exit`
-| Property for terminating the JVM when the context reaches a specific phase. See
-xref:integration/checkpoint-restore.adoc#_automatic_checkpointrestore_at_startup[Automatic
-checkpoint/restore at startup] and
-{spring-framework-api}++/context/support/DefaultLifecycleProcessor.html#EXIT_PROPERTY_NAME++[`DefaultLifecycleProcessor`]
-for details.
-
-| `spring.context.expression.maxLength`
-| The maximum length for
-xref:core/expressions/evaluation.adoc#expressions-parser-configuration[Spring Expression Language]
-expressions used in XML bean definitions, `@Value`, etc.
-
 | `spring.expression.compiler.mode`
 | The mode to use when compiling expressions for the
 xref:core/expressions/evaluation.adoc#expressions-compiler-configuration[Spring Expression Language].
@@ -291,8 +291,6 @@ to consider:
 * `final` classes cannot be proxied, because they cannot be extended.
 * `final` methods cannot be advised, because they cannot be overridden.
 * `private` methods cannot be advised, because they cannot be overridden.
-* Methods that are not visible, typically package private methods in a parent class
-from a different package, cannot be advised because they are effectively private.

 NOTE: There is no need to add CGLIB to your classpath. CGLIB is repackaged and included
 in the `spring-core` JAR. In other words, CGLIB-based AOP works "out of the box", as do
@@ -168,7 +168,7 @@ Kotlin::
 ======

 NOTE: Pooling stateless service objects is not usually necessary. We do not believe it should
-be the default choice, as most stateless objects are naturally thread-safe, and instance
+be the default choice, as most stateless objects are naturally thread safe, and instance
 pooling is problematic if resources are cached.

 Simpler pooling is available by using auto-proxying. You can set the `TargetSource` implementations
@@ -521,8 +521,8 @@ standard AspectJ. The following example shows the `aop.xml` file:
 	<aspectj>

 		<weaver>
-			<!-- only weave classes in our application-specific packages and sub-packages -->
-			<include within="com.xyz..*"/>
+			<!-- only weave classes in our application-specific packages -->
+			<include within="com.xyz.*"/>
 		</weaver>

 		<aspects>
@@ -533,11 +533,6 @@ standard AspectJ. The following example shows the `aop.xml` file:
 	</aspectj>
 ----

-NOTE: It is recommended to only weave specific classes (typically those in the
-application packages, as shown in the `aop.xml` example above) in order
-to avoid side effects such as AspectJ dump files and warnings.
-This is also a best practice from an efficiency perspective.
-
 Now we can move on to the Spring-specific portion of the configuration. We need
 to configure a `LoadTimeWeaver` (explained later). This load-time weaver is the
 essential component responsible for weaving the aspect configuration in one or
@@ -719,29 +714,10 @@ Furthermore, the compiled aspect classes need to be available on the classpath.


 [[aop-aj-ltw-aop_dot_xml]]
-=== `META-INF/aop.xml`
+=== 'META-INF/aop.xml'

 The AspectJ LTW infrastructure is configured by using one or more `META-INF/aop.xml`
 files that are on the Java classpath (either directly or, more typically, in jar files).
-For example:
-
-[source,xml,indent=0,subs="verbatim"]
----
-	<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "https://www.eclipse.org/aspectj/dtd/aspectj.dtd">
-	<aspectj>
-
-		<weaver>
-			<!-- only weave classes in our application-specific packages and sub-packages -->
-			<include within="com.xyz..*"/>
-		</weaver>
-
-	</aspectj>
----
-
-NOTE: It is recommended to only weave specific classes (typically those in the
-application packages, as shown in the `aop.xml` example above) in order
-to avoid side effects such as AspectJ dump files and warnings.
-This is also a best practice from an efficiency perspective.

 The structure and contents of this file is detailed in the LTW part of the
 {aspectj-docs-devguide}/ltw-configuration.html[AspectJ reference
@@ -17,11 +17,8 @@ Applying such optimizations early implies the following restrictions:
 * The beans defined in your application cannot change at runtime, meaning:
 ** `@Profile`, in particular profile-specific configuration needs to be chosen at build time.
 ** `Environment` properties that impact the presence of a bean (`@Conditional`) are only considered at build time.
-* Bean definitions with instance suppliers (lambdas or method references) cannot be transformed ahead-of-time.
-* Beans registered as singletons (using `registerSingleton`, typically from
-`ConfigurableListableBeanFactory`) cannot be transformed ahead-of-time either.
-* As we cannot rely on the instance, make sure that the bean type is as precise as
-possible.
+* Bean definitions with instance suppliers (lambdas or method references) cannot be transformed ahead-of-time (see related {spring-framework-issues}/29555[spring-framework#29555] issue).
+* Make sure that the bean type is as precise as possible.

 TIP: See also the xref:core/aot.adoc#aot.bestpractices[] section.

@@ -30,7 +27,7 @@ A Spring AOT processed application typically generates:

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

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

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

 * Refresh an `ApplicationContext` for AOT processing. Contrary to a traditional refresh, this version only creates bean definitions, not bean instances.
 * Invoke the available `BeanFactoryInitializationAotProcessor` implementations and apply their contributions against the `GenerationContext`.
@@ -70,14 +67,7 @@ include-code::./AotProcessingSample[tag=aotcontext]
 In this mode, xref:core/beans/factory-extension.adoc#beans-factory-extension-factory-postprocessors[`BeanFactoryPostProcessor` implementations] are invoked as usual.
 This includes configuration class parsing, import selectors, classpath scanning, etc.
 Such steps make sure that the `BeanRegistry` contains the relevant bean definitions for the application.
-If bean definitions are guarded by conditions (such as `@Profile`), these are evaluated,
-and bean definitions that don't match their conditions are discarded at this stage.
-
-If custom code needs to register extra beans programmatically, make sure that custom
-registration code uses `BeanDefinitionRegistry` instead of `BeanFactory` as only bean
-definitions are taken into account. A good pattern is to implement
-`ImportBeanDefinitionRegistrar` and register it via an `@Import` on one of your
-configuration classes.
+If bean definitions are guarded by conditions (such as `@Profile`), these are discarded at this stage.

 Because this mode does not actually create bean instances, `BeanPostProcessor` implementations are not invoked, except for specific variants that are relevant for AOT processing.
 These are:
@@ -94,12 +84,12 @@ Once this part completes, the `BeanFactory` contains the bean definitions that a
 Components that want to participate in this step can implement the {spring-framework-api}/beans/factory/aot/BeanFactoryInitializationAotProcessor.html[`BeanFactoryInitializationAotProcessor`] interface.
 Each implementation can return an AOT contribution, based on the state of the bean factory.

-An AOT contribution is a component that contributes generated code which reproduces a particular behavior.
+An AOT contribution is a component that contributes generated code that reproduces a particular behavior.
 It can also contribute `RuntimeHints` to indicate the need for reflection, resource loading, serialization, or JDK proxies.

-A `BeanFactoryInitializationAotProcessor` implementation can be registered in `META-INF/spring/aot.factories` with a key equal to the fully-qualified name of the interface.
+A `BeanFactoryInitializationAotProcessor` implementation can be registered in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the interface.

-The `BeanFactoryInitializationAotProcessor` interface can also be implemented directly by a bean.
+A `BeanFactoryInitializationAotProcessor` can also be implemented directly by a bean.
 In this mode, the bean provides an AOT contribution equivalent to the feature it provides with a regular runtime.
 Consequently, such a bean is automatically excluded from the AOT-optimized context.

@@ -121,7 +111,7 @@ This interface is used as follows:

 * Implemented by a `BeanPostProcessor` bean, to replace its runtime behavior.
 For instance xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp-examples-aabpp[`AutowiredAnnotationBeanPostProcessor`] implements this interface to generate code that injects members annotated with `@Autowired`.
-* Implemented by a type registered in `META-INF/spring/aot.factories` with a key equal to the fully-qualified name of the interface.
+* Implemented by a type registered in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the interface.
 Typically used when the bean definition needs to be tuned for specific features of the core framework.

 [NOTE]
@@ -217,33 +207,11 @@ However, keep in mind that some optimizations are made at build time based on a

 This section lists the best practices that make sure your application is ready for AOT.

-[[aot.bestpractices.bean-registration]]
-== Programmatic bean registration
-
-The AOT engine takes care of the `@Configuration` model and any callback that might be
-invoked as part of processing your configuration. If you need to register additional
-beans programmatically, make sure to use a `BeanDefinitionRegistry` to register
-bean definitions.
-
-This can typically be done via a `BeanDefinitionRegistryPostProcessor`. Note that, if it
-is registered itself as a bean, it will be invoked again at runtime unless you make
-sure to implement `BeanFactoryInitializationAotProcessor` as well. A more idiomatic
-way is to implement `ImportBeanDefinitionRegistrar` and register it using `@Import` on
-one of your configuration classes. This invokes your custom code as part of configuration
-class parsing.
-
-If you declare additional beans programmatically using a different callback, they are
-likely not going to be handled by the AOT engine, and therefore no hints are going to be
-generated for them. Depending on the environment, those beans may not be registered at
-all. For instance, classpath scanning does not work in a native image as there is no
-notion of a classpath. For cases like this, it is crucial that the scanning happens at
-build time.
-
 [[aot.bestpractices.bean-type]]
 === Expose The Most Precise Bean Type

 While your application may interact with an interface that a bean implements, it is still very important to declare the most precise type.
-The AOT engine performs additional checks on the bean type, such as detecting the presence of `@Autowired` members or lifecycle callback methods.
+The AOT engine performs additional checks on the bean type, such as detecting the presence of `@Autowired` members, or lifecycle callback methods.

 For `@Configuration` classes, make sure that the return type of the factory `@Bean` method is as precise as possible.
 Consider the following example:
@@ -294,11 +262,10 @@ If you are registering bean definitions programmatically, consider using `RootBe

 [[aot.bestpractices.constructors]]
 === Avoid Multiple Constructors
-
 The container is able to choose the most appropriate constructor to use based on several candidates.
 However, this is not a best practice and flagging the preferred constructor with `@Autowired` if necessary is preferred.

-In case you are working on a code base that you cannot modify, you can set the {spring-framework-api}/beans/factory/support/AbstractBeanDefinition.html#PREFERRED_CONSTRUCTORS_ATTRIBUTE[`preferredConstructors` attribute] on the related bean definition to indicate which constructor should be used.
+In case you are working on a code base that you can't modify, you can set the {spring-framework-api}/beans/factory/support/AbstractBeanDefinition.html#PREFERRED_CONSTRUCTORS_ATTRIBUTE[`preferredConstructors` attribute] on the related bean definition to indicate which constructor should be used.

 [[aot.bestpractices.factory-bean]]
 === FactoryBean
@@ -316,7 +283,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
 	public class ClientFactoryBean<T extends AbstractClient> implements FactoryBean<T> {
-		// ...
+
 	}
 ----
 ======
@@ -413,7 +380,7 @@ Java::

 Running an application as a native image requires additional information compared to a regular JVM runtime.
 For instance, GraalVM needs to know ahead of time if a component uses reflection.
-Similarly, classpath resources are not included in a native image unless specified explicitly.
+Similarly, classpath resources are not shipped in a native image unless specified explicitly.
 Consequently, if the application needs to load a resource, it must be referenced from the corresponding GraalVM native image configuration file.

 The {spring-framework-api}/aot/hint/RuntimeHints.html[`RuntimeHints`] API collects the need for reflection, resource loading, serialization, and JDK proxies at runtime.
@@ -448,7 +415,7 @@ include-code::./SpellCheckService[]
 If at all possible, `@ImportRuntimeHints` should be used as close as possible to the component that requires the hints.
 This way, if the component is not contributed to the `BeanFactory`, the hints won't be contributed either.

-It is also possible to register an implementation statically by adding an entry in `META-INF/spring/aot.factories` with a key equal to the fully-qualified name of the `RuntimeHintsRegistrar` interface.
+It is also possible to register an implementation statically by adding an entry in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the `RuntimeHintsRegistrar` interface.


 [[aot.hints.reflective]]
@@ -457,7 +424,7 @@ It is also possible to register an implementation statically by adding an entry
 {spring-framework-api}/aot/hint/annotation/Reflective.html[`@Reflective`] provides an idiomatic way to flag the need for reflection on an annotated element.
 For instance, `@EventListener` is meta-annotated with `@Reflective` since the underlying implementation invokes the annotated method using reflection.

-By default, only Spring beans are considered, and an invocation hint is registered for the annotated element.
+By default, only Spring beans are considered and an invocation hint is registered for the annotated element.
 This can be tuned by specifying a custom `ReflectiveProcessor` implementation via the
 `@Reflective` annotation.

@@ -155,8 +155,6 @@ If there is no other resolution indicator (such as a qualifier or a primary mark
 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.
-
-Since version 6.1, this requires the `-parameters` Java compiler flag to be present.
 ====

 That said, if you intend to express annotation-driven injection by name, do not
@@ -141,7 +141,7 @@ Kotlin::
 ====
 After you learn about Spring's IoC container, you may want to know more about Spring's
 `Resource` abstraction (as described in
-xref:core/resources.adoc[Resources])
+xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources])
 which provides a convenient mechanism for reading an InputStream from locations defined
 in a URI syntax. In particular, `Resource` paths are used to construct applications contexts,
 as described in xref:core/resources.adoc#resources-app-ctx[Application Contexts and Resource Paths].
@@ -592,40 +592,6 @@ Kotlin::



-[[beans-factory-thread-safety]]
-=== Thread Safety and Visibility
-
-The Spring core container publishes created singleton instances in a thread-safe manner,
-guarding access through a singleton lock and guaranteeing visibility in other threads.
-
-As a consequence, application-provided bean classes do not have to be concerned about the
-visibility of their initialization state. Regular configuration fields do not have to be
-marked as `volatile` as long as they are only mutated during the initialization phase,
-providing visibility guarantees similar to `final` even for setter-based configuration
-state that is mutable during that initial phase. If such fields get changed after the
-bean creation phase and its subsequent initial publication, they need to be declared as
-`volatile` or guarded by a common lock whenever accessed.
-
-Note that concurrent access to such configuration state in singleton bean instances,
-e.g. for controller instances or repository instances, is perfectly thread-safe after
-such safe initial publication from the container side. This includes common singleton
-`FactoryBean` instances which are processed within the general singleton lock as well.
-
-For destruction callbacks, the configuration state remains thread-safe but any runtime
-state accumulated between initialization and destruction should be kept in thread-safe
-structures (or in `volatile` fields for simple cases) as per common Java guidelines.
-
-Deeper `Lifecycle` integration as shown above involves runtime-mutable state such as
-a `runnable` field which will have to be declared as `volatile`. While the common
-lifecycle callbacks follow a certain order, e.g. a start callback is guaranteed to
-only happen after full initialization and a stop callback only after an initial start,
-there is a special case with the common stop before destroy arrangement: It is strongly
-recommended that the internal state in any such bean also allows for an immediate
-destroy callback without a preceding stop since this may happen during an extraordinary
-shutdown after a cancelled bootstrap or in case of a stop timeout caused by another bean.
-
-
-
 [[beans-factory-aware]]
 == `ApplicationContextAware` and `BeanNameAware`

@@ -324,6 +324,7 @@ Kotlin::



+
 [[beans-factory-scopes-application]]
 === Application Scope

@@ -373,6 +374,7 @@ Kotlin::



+
 [[beans-factory-scopes-websocket]]
 === WebSocket Scope

@@ -382,6 +384,7 @@ xref:web/websocket/stomp/scope.adoc[WebSocket scope] for more details.



+
 [[beans-factory-scopes-other-injection]]
 === Scoped Beans as Dependencies

@@ -541,19 +544,6 @@ see xref:core/aop/proxying.adoc[Proxying Mechanisms].



-[[beans-factory-scopes-injection]]
-=== Injecting Request/Session References Directly
-
-As an alternative to factory scopes, a Spring `WebApplicationContext` also supports
-the injection of `HttpServletRequest`, `HttpServletResponse`, `HttpSession`,
-`WebRequest` and (if JSF is present) `FacesContext` and `ExternalContext` into
-Spring-managed beans, simply through type-based autowiring next to regular injection
-points for other beans. Spring generally injects proxies for such request and session
-objects which has the advantage of working in singleton beans and serializable beans
-as well, similar to scoped proxies for factory-scoped beans.
-
-
-
 [[beans-factory-scopes-custom]]
 == Custom Scopes

@@ -1,11 +1,10 @@
 [[expressions]]
 = Spring Expression Language (SpEL)

-The Spring Expression Language ("SpEL" for short) is a powerful expression language that
+The Spring Expression Language ("`SpEL`" for short) is a powerful expression language that
 supports querying and manipulating an object graph at runtime. The language syntax is
-similar to the https://jakarta.ee/specifications/expression-language/[Jakarta Expression
-Language] but offers additional features, most notably method invocation and basic string
-templating functionality.
+similar to Unified EL but offers additional features, most notably method invocation and
+basic string templating functionality.

 While there are several other Java expression languages available -- OGNL, MVEL, and JBoss
 EL, to name a few -- the Spring Expression Language was created to provide the Spring
@@ -34,24 +33,26 @@ populate them are listed at the end of the chapter.
 The expression language supports the following functionality:

 * Literal expressions
+* Boolean and relational operators
+* Regular expressions
+* Class expressions
 * Accessing properties, arrays, lists, and maps
+* Method invocation
+* Assignment
+* Calling constructors
+* Bean references
+* Array construction
 * Inline lists
 * Inline maps
-* Array construction
-* Relational operators
-* Regular expressions
-* Logical operators
-* String operators
-* Mathematical operators
-* Assignment
-* Type expressions
-* Method invocation
-* Constructor invocation
+* Ternary operator
 * Variables
-* User-defined functions
-* Bean references
-* Ternary, Elvis, and safe-navigation operators
+* User-defined functions added to the context
+  * reflective invocation of `Method`
+  * various cases of `MethodHandle`
 * Collection projection
 * Collection selection
 * Templated expressions

+
+
+
@@ -1,12 +1,12 @@
 [[expressions-evaluation]]
 = Evaluation

-This section introduces programmatic use of SpEL's interfaces and its expression language.
-The complete language reference can be found in the
+This section introduces the simple use of SpEL interfaces and its expression language.
+The complete language reference can be found in
 xref:core/expressions/language-ref.adoc[Language Reference].

-The following code demonstrates how to use the SpEL API to evaluate the literal string
-expression, `Hello World`.
+The following code introduces the SpEL API to evaluate the literal string expression,
+`Hello World`.

 [tabs]
 ======
@@ -18,7 +18,7 @@ Java::
 	Expression exp = parser.parseExpression("'Hello World'"); // <1>
 	String message = (String) exp.getValue();
 ----
-<1> The value of the message variable is `"Hello World"`.
+<1> The value of the message variable is `'Hello World'`.

 Kotlin::
 +
@@ -28,24 +28,24 @@ Kotlin::
 	val exp = parser.parseExpression("'Hello World'") // <1>
 	val message = exp.value as String
 ----
-<1> The value of the message variable is `"Hello World"`.
+<1> The value of the message variable is `'Hello World'`.
 ======

+
 The SpEL classes and interfaces you are most likely to use are located in the
 `org.springframework.expression` package and its sub-packages, such as `spel.support`.

-The `ExpressionParser` interface is responsible for parsing an expression string. In the
-preceding example, the expression string is a string literal denoted by the surrounding
-single quotation marks. The `Expression` interface is responsible for evaluating the
-defined expression string. The two types of exceptions that can be thrown when calling
-`parser.parseExpression(...)` and `exp.getValue(...)` are `ParseException` and
-`EvaluationException`, respectively.
+The `ExpressionParser` interface is responsible for parsing an expression string. In
+the preceding example, the expression string is a string literal denoted by the surrounding single
+quotation marks. The `Expression` interface is responsible for evaluating the previously defined
+expression string. Two exceptions that can be thrown, `ParseException` and
+`EvaluationException`, when calling `parser.parseExpression` and `exp.getValue`,
+respectively.

-SpEL supports a wide range of features such as calling methods, accessing properties,
+SpEL supports a wide range of features, such as calling methods, accessing properties,
 and calling constructors.

-In the following method invocation example, we call the `concat` method on the string
-literal, `Hello World`.
+In the following example of method invocation, we call the `concat` method on the string literal:

 [tabs]
 ======
@@ -57,7 +57,7 @@ Java::
 	Expression exp = parser.parseExpression("'Hello World'.concat('!')"); // <1>
 	String message = (String) exp.getValue();
 ----
-<1> The value of `message` is now `"Hello World!"`.
+<1> The value of `message` is now 'Hello World!'.

 Kotlin::
 +
@@ -67,11 +67,10 @@ Kotlin::
 	val exp = parser.parseExpression("'Hello World'.concat('!')") // <1>
 	val message = exp.value as String
 ----
-<1> The value of `message` is now `"Hello World!"`.
+<1> The value of `message` is now 'Hello World!'.
 ======

-The following example demonstrates how to access the `Bytes` JavaBean property of the
-string literal, `Hello World`.
+The following example of calling a JavaBean property calls the `String` property `Bytes`:

 [tabs]
 ======
@@ -101,10 +100,10 @@ Kotlin::
 ======

 SpEL also supports nested properties by using the standard dot notation (such as
-`prop1.prop2.prop3`) as well as the corresponding setting of property values.
+`prop1.prop2.prop3`) and also the corresponding setting of property values.
 Public fields may also be accessed.

-The following example shows how to use dot notation to get the length of a string literal.
+The following example shows how to use dot notation to get the length of a literal:

 [tabs]
 ======
@@ -134,7 +133,7 @@ Kotlin::
 ======

 The String's constructor can be called instead of using a string literal, as the following
-example shows.
+example shows:

 [tabs]
 ======
@@ -146,7 +145,7 @@ Java::
 	Expression exp = parser.parseExpression("new String('hello world').toUpperCase()"); // <1>
 	String message = exp.getValue(String.class);
 ----
-<1> Construct a new `String` from the literal and convert it to upper case.
+<1> Construct a new `String` from the literal and make it be upper case.

 Kotlin::
 +
@@ -156,9 +155,10 @@ Kotlin::
 	val exp = parser.parseExpression("new String('hello world').toUpperCase()")  // <1>
 	val message = exp.getValue(String::class.java)
 ----
-<1> Construct a new `String` from the literal and convert it to upper case.
+<1> Construct a new `String` from the literal and make it be upper case.
 ======

+
 Note the use of the generic method: `public <T> T getValue(Class<T> desiredResultType)`.
 Using this method removes the need to cast the value of the expression to the desired
 result type. An `EvaluationException` is thrown if the value cannot be cast to the
@@ -166,8 +166,8 @@ type `T` or converted by using the registered type converter.

 The more common usage of SpEL is to provide an expression string that is evaluated
 against a specific object instance (called the root object). The following example shows
-how to retrieve the `name` property from an instance of the `Inventor` class and how to
-reference the `name` property in a boolean expression.
+how to retrieve the `name` property from an instance of the `Inventor` class or
+create a boolean condition:

 [tabs]
 ======
@@ -240,7 +240,7 @@ It excludes Java type references, constructors, and bean references. It also req
 you to explicitly choose the level of support for properties and methods in expressions.
 By default, the `create()` static factory method enables only read access to properties.
 You can also obtain a builder to configure the exact level of support needed, targeting
-one or some combination of the following.
+one or some combination of the following:

 * Custom `PropertyAccessor` only (no reflection)
 * Data binding properties for read-only access
@@ -252,15 +252,16 @@ one or some combination of the following.

 By default, SpEL uses the conversion service available in Spring core
 (`org.springframework.core.convert.ConversionService`). This conversion service comes
-with many built-in converters for common conversions, but is also fully extensible so
-that you can add custom conversions between types. Additionally, it is generics-aware.
-This means that, when you work with generic types in expressions, SpEL attempts
-conversions to maintain type correctness for any objects it encounters.
+with many built-in converters for common conversions but is also fully extensible so that
+you can add custom conversions between types. Additionally, it is
+generics-aware. This means that, when you work with generic types in
+expressions, SpEL attempts conversions to maintain type correctness for any objects
+it encounters.

 What does this mean in practice? Suppose assignment, using `setValue()`, is being used
 to set a `List` property. The type of the property is actually `List<Boolean>`. SpEL
 recognizes that the elements of the list need to be converted to `Boolean` before
-being placed in it. The following example shows how to do so.
+being placed in it. The following example shows how to do so:

 [tabs]
 ======
@@ -324,7 +325,7 @@ constructor before setting the specified value. If the element type does not hav
 default constructor, `null` will be added to the array or list. If there is no built-in
 or custom converter that knows how to set the value, `null` will remain in the array or
 list at the specified index. The following example demonstrates how to automatically grow
-the list.
+the list:

 [tabs]
 ======
@@ -379,25 +380,16 @@ Kotlin::
 ----
 ======

-By default, a SpEL expression cannot contain more than 10,000 characters; however, the
-`maxExpressionLength` is configurable. If you create a `SpelExpressionParser`
-programmatically, you can specify a custom `maxExpressionLength` when creating the
-`SpelParserConfiguration` that you provide to the `SpelExpressionParser`. If you wish to
-set the `maxExpressionLength` used for parsing SpEL expressions within an
-`ApplicationContext` -- for example, in XML bean definitions, `@Value`, etc. -- you can
-set a JVM system property or Spring property named `spring.context.expression.maxLength`
-to the maximum expression length needed by your application (see
-xref:appendix.adoc#appendix-spring-properties[Supported Spring Properties]).


 [[expressions-spel-compilation]]
 == SpEL Compilation

-Spring provides a basic compiler for SpEL expressions. Expressions are usually
-interpreted, which provides a lot of dynamic flexibility during evaluation but does not
-provide optimum performance. For occasional expression usage, this is fine, but, when
-used by other components such as Spring Integration, performance can be very important,
-and there is no real need for the dynamism.
+Spring Framework 4.1 includes a basic expression compiler. Expressions are usually
+interpreted, which provides a lot of dynamic flexibility during evaluation but
+does not provide optimum performance. For occasional expression usage,
+this is fine, but, when used by other components such as Spring Integration,
+performance can be very important, and there is no real need for the dynamism.

 The SpEL compiler is intended to address this need. During evaluation, the compiler
 generates a Java class that embodies the expression behavior at runtime and uses that
@@ -410,17 +402,16 @@ information can cause trouble later if the types of the various expression eleme
 change over time. For this reason, compilation is best suited to expressions whose
 type information is not going to change on repeated evaluations.

-Consider the following basic expression.
+Consider the following basic expression:

-[source,java,indent=0,subs="verbatim,quotes"]
 ----
-	someArray[0].someProperty.someOtherProperty < 0.1
+someArray[0].someProperty.someOtherProperty < 0.1
 ----

-Because the preceding expression involves array access, some property de-referencing, and
-numeric operations, the performance gain can be very noticeable. In an example micro
-benchmark run of 50,000 iterations, it took 75ms to evaluate by using the interpreter and
-only 3ms using the compiled version of the expression.
+Because the preceding expression involves array access, some property de-referencing,
+and numeric operations, the performance gain can be very noticeable. In an example
+micro benchmark run of 50000 iterations, it took 75ms to evaluate by using the
+interpreter and only 3ms using the compiled version of the expression.


 [[expressions-compiler-configuration]]
@@ -428,34 +419,33 @@ only 3ms using the compiled version of the expression.

 The compiler is not turned on by default, but you can turn it on in either of two
 different ways. You can turn it on by using the parser configuration process
-(xref:core/expressions/evaluation.adoc#expressions-parser-configuration[discussed
-earlier]) or by using a Spring property when SpEL usage is embedded inside another
-component. This section discusses both of these options.
+(xref:core/expressions/evaluation.adoc#expressions-parser-configuration[discussed earlier]) or by using a Spring property
+when SpEL usage is embedded inside another component. This section discusses both of
+these options.

 The compiler can operate in one of three modes, which are captured in the
-`org.springframework.expression.spel.SpelCompilerMode` enum. The modes are as follows.
+`org.springframework.expression.spel.SpelCompilerMode` enum. The modes are as follows:

 * `OFF` (default): The compiler is switched off.
 * `IMMEDIATE`: In immediate mode, the expressions are compiled as soon as possible. This
-  is typically after the first interpreted evaluation. If the compiled expression fails
-  (typically due to a type changing, as described earlier), the caller of the expression
-  evaluation receives an exception.
-* `MIXED`: In mixed mode, the expressions silently switch between interpreted and
-  compiled mode over time. After some number of interpreted runs, they switch to compiled
-  form and, if something goes wrong with the compiled form (such as a type changing, as
-  described earlier), the expression automatically switches back to interpreted form
-  again. Sometime later, it may generate another compiled form and switch to it.
-  Basically, the exception that the user gets in `IMMEDIATE` mode is instead handled
-  internally.
+is typically after the first interpreted evaluation. If the compiled expression fails
+(typically due to a type changing, as described earlier), the caller of the expression
+evaluation receives an exception.
+* `MIXED`: In mixed mode, the expressions silently switch between interpreted and compiled
+mode over time. After some number of interpreted runs, they switch to compiled
+form and, if something goes wrong with the compiled form (such as a type changing, as
+described earlier), the expression automatically switches back to interpreted form
+again. Sometime later, it may generate another compiled form and switch to it. Basically,
+the exception that the user gets in `IMMEDIATE` mode is instead handled internally.

 `IMMEDIATE` mode exists because `MIXED` mode could cause issues for expressions that
 have side effects. If a compiled expression blows up after partially succeeding, it
 may have already done something that has affected the state of the system. If this
 has happened, the caller may not want it to silently re-run in interpreted mode,
-since part of the expression may be run twice.
+since part of the expression may be running twice.

 After selecting a mode, use the `SpelParserConfiguration` to configure the parser. The
-following example shows how to do so.
+following example shows how to do so:

 [tabs]
 ======
@@ -492,16 +482,15 @@ Kotlin::
 ----
 ======

-When you specify the compiler mode, you can also specify a `ClassLoader` (passing `null`
-is allowed). Compiled expressions are defined in a child `ClassLoader` created under any
-that is supplied. It is important to ensure that, if a `ClassLoader` is specified, it can
-see all the types involved in the expression evaluation process. If you do not specify a
-`ClassLoader`, a default `ClassLoader` is used (typically the context `ClassLoader` for
-the thread that is running during expression evaluation).
+When you specify the compiler mode, you can also specify a classloader (passing null is allowed).
+Compiled expressions are defined in a child classloader created under any that is supplied.
+It is important to ensure that, if a classloader is specified, it can see all the types involved in
+the expression evaluation process. If you do not specify a classloader, a default classloader is used
+(typically the context classloader for the thread that is running during expression evaluation).

 The second way to configure the compiler is for use when SpEL is embedded inside some
 other component and it may not be possible to configure it through a configuration
-object. In such cases, it is possible to set the `spring.expression.compiler.mode`
+object. In these cases, it is possible to set the `spring.expression.compiler.mode`
 property via a JVM system property (or via the
 xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism) to one of the
 `SpelCompilerMode` enum values (`off`, `immediate`, or `mixed`).
@@ -510,16 +499,18 @@ xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism) to
 [[expressions-compiler-limitations]]
 === Compiler Limitations

-Spring does not support compiling every kind of expression. The primary focus is on
-common expressions that are likely to be used in performance-critical contexts. The
-following kinds of expressions cannot be compiled.
+Since Spring Framework 4.1, the basic compilation framework is in place. However, the framework
+does not yet support compiling every kind of expression. The initial focus has been on the
+common expressions that are likely to be used in performance-critical contexts. The following
+kinds of expression cannot be compiled at the moment:

 * Expressions involving assignment
 * Expressions relying on the conversion service
 * Expressions using custom resolvers or accessors
-* Expressions using overloaded operators
-* Expressions using array construction syntax
 * Expressions using selection or projection

-Compilation of additional kinds of expressions may be supported in the future.
+More types of expressions will be compilable in the future.
+
+
+

@@ -3,11 +3,9 @@

 This section lists the classes used in the examples throughout this chapter.

-== `Inventor`
-
 [tabs]
 ======
-Java::
+Inventor.Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary",chomp="-packages"]
 ----
@@ -82,7 +80,7 @@ Java::
 	}
 ----

-Kotlin::
+Inventor.kt::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary",chomp="-packages"]
 ----
@@ -97,11 +95,9 @@ Kotlin::
 ----
 ======

-== `PlaceOfBirth`
-
 [tabs]
 ======
-Java::
+PlaceOfBirth.java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary",chomp="-packages"]
 ----
@@ -139,7 +135,7 @@ Java::
 	}
 ----

-Kotlin::
+PlaceOfBirth.kt::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary",chomp="-packages"]
 ----
@@ -149,11 +145,9 @@ Kotlin::
 ----
 ======

-== `Society`
-
 [tabs]
 ======
-Java::
+Society.java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary",chomp="-packages"]
 ----
@@ -198,7 +192,7 @@ Java::
 	}
 ----

-Kotlin::
+Society.kt::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary",chomp="-packages"]
 ----
@@ -13,7 +13,7 @@ Java::
 	int[] numbers1 = (int[]) parser.parseExpression("new int[4]").getValue(context);

 	// Array with initializer
-	int[] numbers2 = (int[]) parser.parseExpression("new int[] {1, 2, 3}").getValue(context);
+	int[] numbers2 = (int[]) parser.parseExpression("new int[]{1,2,3}").getValue(context);

 	// Multi dimensional array
 	int[][] numbers3 = (int[][]) parser.parseExpression("new int[4][5]").getValue(context);
@@ -26,22 +26,14 @@ Kotlin::
 	val numbers1 = parser.parseExpression("new int[4]").getValue(context) as IntArray

 	// Array with initializer
-	val numbers2 = parser.parseExpression("new int[] {1, 2, 3}").getValue(context) as IntArray
+	val numbers2 = parser.parseExpression("new int[]{1,2,3}").getValue(context) as IntArray

 	// Multi dimensional array
 	val numbers3 = parser.parseExpression("new int[4][5]").getValue(context) as Array<IntArray>
 ----
 ======

-[NOTE]
-====
 You cannot currently supply an initializer when you construct a multi-dimensional array.
-====

-[CAUTION]
-====
-Any expression that constructs an array – for example, via `new int[4]` or
-`new int[] {1, 2, 3}` – cannot be compiled. See
-xref:core/expressions/evaluation.adoc#expressions-compiler-limitations[Compiler Limitations]
-for details.
-====
+
+
@@ -4,7 +4,7 @@
 Projection lets a collection drive the evaluation of a sub-expression, and the result is
 a new collection. The syntax for projection is `.![projectionExpression]`. For example,
 suppose we have a list of inventors but want the list of cities where they were born.
-Effectively, we want to evaluate `placeOfBirth.city` for every entry in the inventor
+Effectively, we want to evaluate 'placeOfBirth.city' for every entry in the inventor
 list. The following example uses projection to do so:

 [tabs]
@@ -13,18 +13,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	// evaluates to ["Smiljan", "Idvor"]
-	List placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]")
-			.getValue(societyContext, List.class);
+	// returns ['Smiljan', 'Idvor' ]
+	List placesOfBirth = (List)parser.parseExpression("members.![placeOfBirth.city]");
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	// evaluates to ["Smiljan", "Idvor"]
-	val placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]")
-	 		.getValue(societyContext) as List<*>
+	// returns ['Smiljan', 'Idvor' ]
+	val placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]") as List<*>
 ----
 ======

@@ -34,12 +32,5 @@ evaluated against each entry in the map (represented as a Java `Map.Entry`). The
 of a projection across a map is a list that consists of the evaluation of the projection
 expression against each map entry.

-[NOTE]
-====
-The Spring Expression Language also supports safe navigation for collection projection.

-See
-xref:core/expressions/language-ref/operator-safe-navigation.adoc#expressions-operator-safe-navigation-selection-and-projection[Safe Collection Selection and Projection]
-for details.
-====

@@ -28,14 +28,13 @@ Kotlin::
 ======

 Selection is supported for arrays and anything that implements `java.lang.Iterable` or
-`java.util.Map`. For an array or `Iterable`, the selection expression is evaluated
-against each individual element. Against a map, the selection expression is evaluated
-against each map entry (objects of the Java type `Map.Entry`). Each map entry has its
-`key` and `value` accessible as properties for use in the selection.
+`java.util.Map`. For a list or array, the selection criteria is evaluated against each
+individual element. Against a map, the selection criteria is evaluated against each map
+entry (objects of the Java type `Map.Entry`). Each map entry has its `key` and `value`
+accessible as properties for use in the selection.

-Given a `Map` stored in a variable named `#map`, the following expression returns a new
-map that consists of those elements of the original map where the entry's value is less
-than 27:
+The following expression returns a new map that consists of those elements of the
+original map where the entry's value is less than 27:

 [tabs]
 ======
@@ -43,28 +42,21 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	Map newMap = parser.parseExpression("#map.?[value < 27]").getValue(Map.class);
+	Map newMap = parser.parseExpression("map.?[value<27]").getValue();
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	val newMap = parser.parseExpression("#map.?[value < 27]").getValue() as Map
+	val newMap = parser.parseExpression("map.?[value<27]").getValue()
 ----
 ======

 In addition to returning all the selected elements, you can retrieve only the first or
-the last element. To obtain the first element matching the selection expression, the
-syntax is `.^[selectionExpression]`. To obtain the last element matching the selection
-expression, the syntax is `.$[selectionExpression]`.
+the last element. To obtain the first element matching the selection, the syntax is
+`.^[selectionExpression]`. To obtain the last matching selection, the syntax is
+`.$[selectionExpression]`.

-[NOTE]
-====
-The Spring Expression Language also supports safe navigation for collection selection.

-See
-xref:core/expressions/language-ref/operator-safe-navigation.adoc#expressions-operator-safe-navigation-selection-and-projection[Safe Collection Selection and Projection]
-for details.
-====

@@ -1,26 +1,10 @@
 [[expressions-ref-functions]]
 = Functions

-You can extend SpEL by registering user-defined functions that can be called within
-expressions by using the `#functionName(...)` syntax. Functions can be registered as
-variables in `EvaluationContext` implementations via the `setVariable()` method.
-
-[TIP]
-====
-`StandardEvaluationContext` also defines `registerFunction(...)` methods that provide a
-convenient way to register a function as a `java.lang.reflect.Method` or a
-`java.lang.invoke.MethodHandle`.
-====
-
-[WARNING]
-====
-Since functions share a common namespace with
-xref:core/expressions/language-ref/variables.adoc[variables] in the evaluation context,
-care must be taken to ensure that function names and variable names do not overlap.
-====
-
-The following example shows how to register a user-defined function to be invoked via
-reflection using a `java.lang.reflect.Method`:
+You can extend SpEL by registering user-defined functions that can be called within the
+expression string. The function is registered through the `EvaluationContext`. The
+following example shows how to register a user-defined function to be invoked via reflection
+(i.e. a `Method`):

 [tabs]
 ======
@@ -56,7 +40,11 @@ Java::
 	public abstract class StringUtils {

 		public static String reverseString(String input) {
-			return new StringBuilder(input).reverse().toString();
+			StringBuilder backwards = new StringBuilder(input.length());
+			for (int i = 0; i < input.length(); i++) {
+				backwards.append(input.charAt(input.length() - 1 - i));
+			}
+			return backwards.toString();
 		}
 	}
 ----
@@ -66,12 +54,16 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
 	fun reverseString(input: String): String {
-		return StringBuilder(input).reverse().toString()
+		val backwards = StringBuilder(input.length)
+		for (i in 0 until input.length) {
+			backwards.append(input[input.length - 1 - i])
+		}
+		return backwards.toString()
 	}
 ----
 ======

-You can register and use the preceding method, as the following example shows:
+You can then register and use the preceding method, as the following example shows:

 [tabs]
 ======
@@ -83,9 +75,8 @@ Java::

 	EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
 	context.setVariable("reverseString",
-			StringUtils.class.getMethod("reverseString", String.class));
+			StringUtils.class.getDeclaredMethod("reverseString", String.class));

-	// evaluates to "olleh"
 	String helloWorldReversed = parser.parseExpression(
 			"#reverseString('hello')").getValue(context, String.class);
 ----
@@ -97,18 +88,16 @@ Kotlin::
 	val parser = SpelExpressionParser()

 	val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
-	context.setVariable("reverseString", ::reverseString.javaMethod)
+	context.setVariable("reverseString", ::reverseString::javaMethod)

-	// evaluates to "olleh"
 	val helloWorldReversed = parser.parseExpression(
 			"#reverseString('hello')").getValue(context, String::class.java)
 ----
 ======

-A function can also be registered as a `java.lang.invoke.MethodHandle`. This enables
-potentially more efficient use cases if the `MethodHandle` target and parameters have
-been fully bound prior to registration; however, partially bound handles are also
-supported.
+The use of `MethodHandle` is also supported. This enables potentially more efficient use
+cases if the `MethodHandle` target and parameters have been fully bound prior to
+registration, but partially bound handles are also supported.

 Consider the `String#formatted(String, Object...)` instance method, which produces a
 message according to a template and a variable number of arguments.
@@ -129,9 +118,9 @@ Java::
 			MethodType.methodType(String.class, Object[].class));
 	context.setVariable("message", mh);

-	// evaluates to "Simple message: <Hello World>"
 	String message = parser.parseExpression("#message('Simple message: <%s>', 'Hello World', 'ignored')")
 			.getValue(context, String.class);
+	//returns "Simple message: <Hello World>"
 ----

 Kotlin::
@@ -145,7 +134,6 @@ Kotlin::
 			MethodType.methodType(String::class.java, Array<Any>::class.java))
 	context.setVariable("message", mh)

-	// evaluates to "Simple message: <Hello World>"
 	val message = parser.parseExpression("#message('Simple message: <%s>', 'Hello World', 'ignored')")
 			.getValue(context, String::class.java)
 ----
@@ -173,9 +161,9 @@ Java::
 			.bindTo(varargs); //here we have to provide arguments in a single array binding
 	context.setVariable("message", mh);

-	// evaluates to "This is a prerecorded message with 3 words: <Oh Hello World!>"
 	String message = parser.parseExpression("#message()")
 			.getValue(context, String.class);
+	//returns "This is a prerecorded message with 3 words: <Oh Hello World!>"
 ----

 Kotlin::
@@ -194,7 +182,6 @@ Kotlin::
 			.bindTo(varargs) //here we have to provide arguments in a single array binding
 	context.setVariable("message", mh)

-	// evaluates to "This is a prerecorded message with 3 words: <Oh Hello World!>"
 	val message = parser.parseExpression("#message()")
 			.getValue(context, String::class.java)
 ----
@@ -3,46 +3,20 @@

 SpEL supports the following types of literal expressions.

-String ::
-  Strings can be delimited by single quotation marks (`'`) or double quotation marks
-  (`"`). To include a single quotation mark within a string literal enclosed in single
-  quotation marks, use two adjacent single quotation mark characters. Similarly, to
-  include a double quotation mark within a string literal enclosed in double quotation
-  marks, use two adjacent double quotation mark characters.
-Number ::
-  Numbers support the use of the negative sign, exponential notation, and decimal points.
-  * Integer: `int` or `long`
-  * Hexadecimal: `int` or `long`
-  * Real: `float` or `double`
-  ** By default, real numbers are parsed using `Double.parseDouble()`.
-Boolean ::
-  `true` or `false`
-Null ::
-  `null`
+- strings
+- numeric values: integer (`int` or `long`), hexadecimal (`int` or `long`), real (`float`
+  or `double`)
+- boolean values: `true` or `false`
+- null

-[NOTE]
-====
-Due to the design and implementation of the Spring Expression Language, literal numbers
-are always stored internally as positive numbers.
+Strings can delimited by single quotation marks (`'`) or double quotation marks (`"`). To
+include a single quotation mark within a string literal enclosed in single quotation
+marks, use two adjacent single quotation mark characters. Similarly, to include a double
+quotation mark within a string literal enclosed in double quotation marks, use two
+adjacent double quotation mark characters.

-For example, `-2` is stored internally as a positive `2` which is then negated while
-evaluating the expression (by calculating the value of `0 - 2`).
-
-This means that it is not possible to represent a negative literal number equal to the
-minimum value of that type of number in Java. For example, the minimum supported value
-for an `int` in Java is `Integer.MIN_VALUE` which has a value of `-2147483648`. However,
-if you include `-2147483648` in a SpEL expression, an exception will be thrown informing
-you that the value `2147483648` cannot be parsed as an `int` (because it exceeds the
-value of `Integer.MAX_VALUE` which is `2147483647`).
-
-If you need to use the minimum value for a particular type of number within a SpEL
-expression, you can either reference the `MIN_VALUE` constant for the respective wrapper
-type (such as `Integer.MIN_VALUE`, `Long.MIN_VALUE`, etc.) or calculate the minimum
-value. For example, to use the minimum integer value:
-
- `T(Integer).MIN_VALUE` -- requires a `StandardEvaluationContext`
- `-2^31` -- can be used with any type of `EvaluationContext`
-====
+Numbers support the use of the negative sign, exponential notation, and decimal points.
+By default, real numbers are parsed by using `Double.parseDouble()`.

 The following listing shows simple usage of literals. Typically, they are not used in
 isolation like this but, rather, as part of a more complex expression -- for example,
@@ -1,27 +1,12 @@
 [[expressions-operator-safe-navigation]]
 = Safe Navigation Operator

-The safe navigation operator (`?`) is used to avoid a `NullPointerException` and comes
-from the https://www.groovy-lang.org/operators.html#_safe_navigation_operator[Groovy]
-language. Typically, when you have a reference to an object, you might need to verify
-that it is not `null` before accessing methods or properties of the object. To avoid
-this, the safe navigation operator returns `null` for the particular null-safe operation
-instead of throwing an exception.
-
-[WARNING]
-====
-When the safe navigation operator evaluates to `null` for a particular null-safe
-operation within a compound expression, the remainder of the compound expression will
-still be evaluated.
-
-See <<expressions-operator-safe-navigation-compound-expressions>> for details.
-====
-
-[[expressions-operator-safe-navigation-property-access]]
-== Safe Property and Method Access
-
-The following example shows how to use the safe navigation operator for property access
-(`?.`).
+The safe navigation operator is used to avoid a `NullPointerException` and comes from
+the https://www.groovy-lang.org/operators.html#_safe_navigation_operator[Groovy]
+language. Typically, when you have a reference to an object, you might need to verify that
+it is not null before accessing methods or properties of the object. To avoid this, the
+safe navigation operator returns null instead of throwing an exception. The following
+example shows how to use the safe navigation operator:

 [tabs]
 ======
@@ -35,18 +20,13 @@ Java::
 	Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
 	tesla.setPlaceOfBirth(new PlaceOfBirth("Smiljan"));

-	// evaluates to "Smiljan"
-	String city = parser.parseExpression("placeOfBirth?.city") // <1>
-			.getValue(context, tesla, String.class);
+	String city = parser.parseExpression("placeOfBirth?.city").getValue(context, tesla, String.class);
+	System.out.println(city);  // Smiljan

 	tesla.setPlaceOfBirth(null);
-
-	// evaluates to null - does not throw NullPointerException
-	city = parser.parseExpression("placeOfBirth?.city") // <2>
-			.getValue(context, tesla, String.class);	
+	city = parser.parseExpression("placeOfBirth?.city").getValue(context, tesla, String.class);
+	System.out.println(city);  // null - does not throw NullPointerException!!!
 ----
-<1> Use safe navigation operator on non-null `placeOfBirth` property
-<2> Use safe navigation operator on null `placeOfBirth` property

 Kotlin::
 +
@@ -58,306 +38,14 @@ Kotlin::
 	val tesla = Inventor("Nikola Tesla", "Serbian")
 	tesla.setPlaceOfBirth(PlaceOfBirth("Smiljan"))

-	// evaluates to "Smiljan"
-	var city = parser.parseExpression("placeOfBirth?.city") // <1>
-			.getValue(context, tesla, String::class.java)
+	var city = parser.parseExpression("placeOfBirth?.city").getValue(context, tesla, String::class.java)
+	println(city)  // Smiljan

 	tesla.setPlaceOfBirth(null)
-
-	// evaluates to null - does not throw NullPointerException
-	city = parser.parseExpression("placeOfBirth?.city") // <2>
-			.getValue(context, tesla, String::class.java)
+	city = parser.parseExpression("placeOfBirth?.city").getValue(context, tesla, String::class.java)
+	println(city)  // null - does not throw NullPointerException!!!
 ----
-<1> Use safe navigation operator on non-null `placeOfBirth` property
-<2> Use safe navigation operator on null `placeOfBirth` property
-======
-
-[NOTE]
-====
-The safe navigation operator also applies to method invocations on an object.
-
-For example, the expression `#calculator?.max(4, 2)` evaluates to `null` if the
-`#calculator` variable has not been configured in the context. Otherwise, the
-`max(int, int)` method will be invoked on the `#calculator`.
-====
-
-
-[[expressions-operator-safe-navigation-selection-and-projection]]
-== Safe Collection Selection and Projection
-
-The Spring Expression Language supports safe navigation for
-xref:core/expressions/language-ref/collection-selection.adoc[collection selection] and
-xref:core/expressions/language-ref/collection-projection.adoc[collection projection] via
-the following operators.
-
-* null-safe selection: `?.?`
-* null-safe select first: `?.^`
-* null-safe select last: `?.$`
-* null-safe projection: `?.!`
-
-The following example shows how to use the safe navigation operator for collection
-selection (`?.?`).
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-	String expression = "members?.?[nationality == 'Serbian']"; // <1>
-
-	// evaluates to [Inventor("Nikola Tesla")]
-	List<Inventor> list = (List<Inventor>) parser.parseExpression(expression)
-			.getValue(context);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	list = (List<Inventor>) parser.parseExpression(expression)
-			.getValue(context);
----
-<1> Use null-safe selection operator on potentially null `members` list
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-	val expression = "members?.?[nationality == 'Serbian']" // <1>
-
-	// evaluates to [Inventor("Nikola Tesla")]
-	var list = parser.parseExpression(expression)
-			.getValue(context) as List<Inventor>
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	list = parser.parseExpression(expression)
-			.getValue(context) as List<Inventor>
----
-<1> Use null-safe selection operator on potentially null `members` list
-======
-
-The following example shows how to use the "null-safe select first" operator for
-collections (`?.^`).
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-	String expression =
-		"members?.^[nationality == 'Serbian' || nationality == 'Idvor']"; // <1>
-
-	// evaluates to Inventor("Nikola Tesla")
-	Inventor inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor.class);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor.class);
----
-<1> Use "null-safe select first" operator on potentially null `members` list
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-	val expression =
-		"members?.^[nationality == 'Serbian' || nationality == 'Idvor']" // <1>
-
-	// evaluates to Inventor("Nikola Tesla")
-	var inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor::class.java)
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor::class.java)
----
-<1> Use "null-safe select first" operator on potentially null `members` list
 ======


-The following example shows how to use the "null-safe select last" operator for
-collections (`?.$`).

-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-	String expression =
-		"members?.$[nationality == 'Serbian' || nationality == 'Idvor']"; // <1>
-
-	// evaluates to Inventor("Pupin")
-	Inventor inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor.class);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor.class);
----
-<1> Use "null-safe select last" operator on potentially null `members` list
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-	val expression =
-		"members?.$[nationality == 'Serbian' || nationality == 'Idvor']" // <1>
-
-	// evaluates to Inventor("Pupin")
-	var inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor::class.java)
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor::class.java)
----
-<1> Use "null-safe select last" operator on potentially null `members` list
-======
-
-The following example shows how to use the safe navigation operator for collection
-projection (`?.!`).
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-
-	// evaluates to ["Smiljan", "Idvor"]
-	List placesOfBirth = parser.parseExpression("members?.![placeOfBirth.city]") // <1>
-			.getValue(context, List.class);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	placesOfBirth = parser.parseExpression("members?.![placeOfBirth.city]") // <2>
-			.getValue(context, List.class);
----
-<1> Use null-safe projection operator on non-null `members` list
-<2> Use null-safe projection operator on null `members` list
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-
-	// evaluates to ["Smiljan", "Idvor"]
-	var placesOfBirth = parser.parseExpression("members?.![placeOfBirth.city]") // <1>
-			.getValue(context, List::class.java)
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	placesOfBirth = parser.parseExpression("members?.![placeOfBirth.city]") // <2>
-			.getValue(context, List::class.java)
----
-<1> Use null-safe projection operator on non-null `members` list
-<2> Use null-safe projection operator on null `members` list
-======
-
-
-[[expressions-operator-safe-navigation-compound-expressions]]
-== Null-safe Operations in Compound Expressions
-
-As mentioned at the beginning of this section, when the safe navigation operator
-evaluates to `null` for a particular null-safe operation within a compound expression,
-the remainder of the compound expression will still be evaluated. This means that the
-safe navigation operator must be applied throughout a compound expression in order to
-avoid any unwanted `NullPointerException`.
-
-Given the expression `#person?.address.city`, if `#person` is `null` the safe navigation
-operator (`?.`) ensures that no exception will be thrown when attempting to access the
-`address` property of `#person`. However, since `#person?.address` evaluates to `null`, a
-`NullPointerException` will be thrown when attempting to access the `city` property of
-`null`. To address that, you can apply null-safe navigation throughout the compound
-expression as in `#person?.address?.city`. That expression will safely evaluate to `null`
-if either `#person` or `#person?.address` evaluates to `null`.
-
-The following example demonstrates how to use the "null-safe select first" operator
-(`?.^`) on a collection combined with null-safe property access (`?.`) within a compound
-expression. If `members` is `null`, the result of the "null-safe select first" operator
-(`members?.^[nationality == 'Serbian']`) evaluates to `null`, and the additional use of
-the safe navigation operator (`?.name`) ensures that the entire compound expression
-evaluates to `null` instead of throwing an exception.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-	String expression = "members?.^[nationality == 'Serbian']?.name"; // <1>
-
-	// evaluates to "Nikola Tesla"
-	String name = parser.parseExpression(expression)
-			.getValue(context, String.class);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	name = parser.parseExpression(expression)
-			.getValue(context, String.class);
----
-<1> Use "null-safe select first" and null-safe property access operators within compound expression.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-	val expression = "members?.^[nationality == 'Serbian']?.name" // <1>
-
-	// evaluates to "Nikola Tesla"
-	String name = parser.parseExpression(expression)
-			.getValue(context, String::class.java)
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	name = parser.parseExpression(expression)
-			.getValue(context, String::class.java)
----
-<1> Use "null-safe select first" and null-safe property access operators within compound expression.
-======
@@ -5,11 +5,8 @@ The Spring Expression Language supports the following kinds of operators:

 * xref:core/expressions/language-ref/operators.adoc#expressions-operators-relational[Relational Operators]
 * xref:core/expressions/language-ref/operators.adoc#expressions-operators-logical[Logical Operators]
-* xref:core/expressions/language-ref/operators.adoc#expressions-operators-string[String Operators]
 * xref:core/expressions/language-ref/operators.adoc#expressions-operators-mathematical[Mathematical Operators]
 * xref:core/expressions/language-ref/operators.adoc#expressions-assignment[The Assignment Operator]
-* xref:core/expressions/language-ref/operators.adoc#expressions-operators-overloaded[Overloaded Operators]
-


 [[expressions-operators-relational]]
@@ -18,7 +15,7 @@ The Spring Expression Language supports the following kinds of operators:
 The relational operators (equal, not equal, less than, less than or equal, greater than,
 and greater than or equal) are supported by using standard operator notation.
 These operators work on `Number` types as well as types implementing `Comparable`.
-The following listing shows a few examples of relational operators:
+The following listing shows a few examples of operators:

 [tabs]
 ======
@@ -68,22 +65,8 @@ If you prefer numeric comparisons instead, avoid number-based `null` comparisons
 in favor of comparisons against zero (for example, `X > 0` or `X < 0`).
 ====

-Each symbolic operator can also be specified as a purely textual equivalent. This avoids
-problems where the symbols used have special meaning for the document type in which the
-expression is embedded (such as in an XML document). The textual equivalents are:
-
-* `lt` (`<`)
-* `gt` (`>`)
-* `le` (`\<=`)
-* `ge` (`>=`)
-* `eq` (`==`)
-* `ne` (`!=`)
-
-All of the textual operators are case-insensitive.
-
-In addition to the standard relational operators, SpEL supports the `between`,
-`instanceof`, and regular expression-based `matches` operators. The following listing
-shows examples of all three:
+In addition to the standard relational operators, SpEL supports the `instanceof` and regular
+expression-based `matches` operator. The following listing shows examples of both:

 [tabs]
 ======
@@ -91,38 +74,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	boolean result;
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"1 between {1, 5}").getValue(Boolean.class);
-
 	// evaluates to false
-	result = parser.parseExpression(
-			"1 between {10, 15}").getValue(Boolean.class);
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"'elephant' between {'aardvark', 'zebra'}").getValue(Boolean.class);
-
-	// evaluates to false
-	result = parser.parseExpression(
-			"'elephant' between {'aardvark', 'cobra'}").getValue(Boolean.class);
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"123 instanceof T(Integer)").getValue(Boolean.class);
-
-	// evaluates to false
-	result = parser.parseExpression(
+	boolean falseValue = parser.parseExpression(
 			"'xyz' instanceof T(Integer)").getValue(Boolean.class);

 	// evaluates to true
-	result = parser.parseExpression(
+	boolean trueValue = parser.parseExpression(
 			"'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);

 	// evaluates to false
-	result = parser.parseExpression(
+	boolean falseValue = parser.parseExpression(
 			"'5.0067' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);
 ----

@@ -130,65 +91,50 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	// evaluates to true
-	var result = parser.parseExpression(
-			"1 between {1, 5}").getValue(Boolean::class.java)
-
 	// evaluates to false
-	result = parser.parseExpression(
-			"1 between {10, 15}").getValue(Boolean::class.java)
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"'elephant' between {'aardvark', 'zebra'}").getValue(Boolean::class.java)
-
-	// evaluates to false
-	result = parser.parseExpression(
-			"'elephant' between {'aardvark', 'cobra'}").getValue(Boolean::class.java)
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"123 instanceof T(Integer)").getValue(Boolean::class.java)
-
-	// evaluates to false
-	result = parser.parseExpression(
+	val falseValue = parser.parseExpression(
 			"'xyz' instanceof T(Integer)").getValue(Boolean::class.java)

 	// evaluates to true
-	result = parser.parseExpression(
+	val trueValue = parser.parseExpression(
 			"'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean::class.java)

 	// evaluates to false
-	result = parser.parseExpression(
+	val falseValue = parser.parseExpression(
 			"'5.0067' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean::class.java)
 ----
 ======

-[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>}`.
-
-Consequently, `1 between {1, 5}` evaluates to `true`, while `1 between {5, 1}` evaluates
-to `false`.
-====
-
 CAUTION: Be careful with primitive types, as they are immediately boxed up to their
 wrapper types. For example, `1 instanceof T(int)` evaluates to `false`, while
-`1 instanceof T(Integer)` evaluates to `true`.
+`1 instanceof T(Integer)` evaluates to `true`, as expected.
+
+Each symbolic operator can also be specified as a purely alphabetic equivalent. This
+avoids problems where the symbols used have special meaning for the document type in
+which the expression is embedded (such as in an XML document). The textual equivalents are:
+
+* `lt` (`<`)
+* `gt` (`>`)
+* `le` (`\<=`)
+* `ge` (`>=`)
+* `eq` (`==`)
+* `ne` (`!=`)
+* `div` (`/`)
+* `mod` (`%`)
+* `not` (`!`).
+
+All of the textual operators are case-insensitive.


 [[expressions-operators-logical]]
 == Logical Operators

-SpEL supports the following logical (`boolean`) operators:
+SpEL supports the following logical operators:

 * `and` (`&&`)
 * `or` (`||`)
 * `not` (`!`)

-All of the textual operators are case-insensitive.
-
 The following example shows how to use the logical operators:

 [tabs]
@@ -221,7 +167,6 @@ Java::
 	boolean falseValue = parser.parseExpression("!true").getValue(Boolean.class);

 	// -- AND and NOT --
-
 	String expression = "isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')";
 	boolean falseValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class);
 ----
@@ -254,105 +199,20 @@ Kotlin::
 	val falseValue = parser.parseExpression("!true").getValue(Boolean::class.java)

 	// -- AND and NOT --
-
 	val expression = "isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')"
 	val falseValue = parser.parseExpression(expression).getValue(societyContext, Boolean::class.java)
 ----
 ======


-[[expressions-operators-string]]
-== String Operators
-
-You can use the following operators on strings.
-
-* concatenation (`+`)
-* subtraction (`-`)
-  - for use with a string containing a single character
-* repeat (`*`)
-
-The following example shows the `String` operators in use:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	// -- Concatenation --
-
-	// evaluates to "hello world"
-	String helloWorld = parser.parseExpression("'hello' + ' ' + 'world'")
-			.getValue(String.class);
-
-	// -- Character Subtraction --
-
-	// evaluates to 'a'
-	char ch = parser.parseExpression("'d' - 3")
-			.getValue(char.class);
-
-	// -- Repeat --
-
-	// evaluates to "abcabc"
-	String repeated = parser.parseExpression("'abc' * 2")
-			.getValue(String.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	// -- Concatenation --
-
-	// evaluates to "hello world"
-	val helloWorld = parser.parseExpression("'hello' + ' ' + 'world'")
-			.getValue(String::class.java)
-
-	// -- Character Subtraction --
-
-	// evaluates to 'a'
-	val ch = parser.parseExpression("'d' - 3")
-			.getValue(Character::class.java);
-
-	// -- Repeat --
-
-	// evaluates to "abcabc"
-	val repeated = parser.parseExpression("'abc' * 2")
-			.getValue(String::class.java);
----
-======
-
 [[expressions-operators-mathematical]]
 == Mathematical Operators

-You can use the following operators on numbers, and standard operator precedence is enforced.
-
-* addition (`+`)
-* subtraction (`-`)
-* increment (`{pp}`)
-* decrement (`--`)
-* multiplication (`*`)
-* division (`/`)
-* modulus (`%`)
-* exponential power (`^`)
-
-The division and modulus operators can also be specified as a purely textual equivalent.
-This avoids problems where the symbols used have special meaning for the document type in
-which the expression is embedded (such as in an XML document). The textual equivalents
-are:
-
-* `div` (`/`)
-* `mod` (`%`)
-
-All of the textual operators are case-insensitive.
-
-[NOTE]
-====
-The increment and decrement operators can be used with either prefix (`{pp}A`, `--A`) or
-postfix (`A{pp}`, `A--`) notation with variables or properties that can be written to.
-====
-
-The following example shows the mathematical operators in use:
+You can use the addition operator (`+`) on both numbers and strings. You can use the
+subtraction (`-`), multiplication (`*`), and division (`/`) operators only on numbers.
+You can also use the modulus (`%`) and exponential power (`^`) operators on numbers.
+Standard operator precedence is enforced. The following example shows the mathematical
+operators in use:

 [tabs]
 ======
@@ -360,131 +220,67 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	Inventor inventor = new Inventor();
-	EvaluationContext context = SimpleEvaluationContext.forReadWriteDataBinding().build();
+	// Addition
+	int two = parser.parseExpression("1 + 1").getValue(Integer.class);  // 2

-	// -- Addition --
+	String testString = parser.parseExpression(
+			"'test' + ' ' + 'string'").getValue(String.class);  // 'test string'

-	int two = parser.parseExpression("1 + 1").getValue(int.class);  // 2
+	// Subtraction
+	int four = parser.parseExpression("1 - -3").getValue(Integer.class);  // 4

-	// -- Subtraction --
+	double d = parser.parseExpression("1000.00 - 1e4").getValue(Double.class);  // -9000

-	int four = parser.parseExpression("1 - -3").getValue(int.class);  // 4
+	// Multiplication
+	int six = parser.parseExpression("-2 * -3").getValue(Integer.class);  // 6

-	double d = parser.parseExpression("1000.00 - 1e4").getValue(double.class);  // -9000
+	double twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(Double.class);  // 24.0

-	// -- Increment --
+	// Division
+	int minusTwo = parser.parseExpression("6 / -3").getValue(Integer.class);  // -2

-	// The counter property in Inventor has an initial value of 0.
+	double one = parser.parseExpression("8.0 / 4e0 / 2").getValue(Double.class);  // 1.0

-	// evaluates to 2; counter is now 1
-	two = parser.parseExpression("counter++ + 2").getValue(context, inventor, int.class);
+	// Modulus
+	int three = parser.parseExpression("7 % 4").getValue(Integer.class);  // 3

-	// evaluates to 5; counter is now 2
-	int five = parser.parseExpression("3 + ++counter").getValue(context, inventor, int.class);
+	int one = parser.parseExpression("8 / 5 % 2").getValue(Integer.class);  // 1

-	// -- Decrement --
-
-	// The counter property in Inventor has a value of 2.
-
-	// evaluates to 6; counter is now 1
-	int six = parser.parseExpression("counter-- + 4").getValue(context, inventor, int.class);
-
-	// evaluates to 5; counter is now 0
-	five = parser.parseExpression("5 + --counter").getValue(context, inventor, int.class);
-
-	// -- Multiplication --
-
-	six = parser.parseExpression("-2 * -3").getValue(int.class);  // 6
-
-	double twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(double.class);  // 24.0
-
-	// -- Division --
-
-	int minusTwo = parser.parseExpression("6 / -3").getValue(int.class);  // -2
-
-	double one = parser.parseExpression("8.0 / 4e0 / 2").getValue(double.class);  // 1.0
-
-	// -- Modulus --
-
-	int three = parser.parseExpression("7 % 4").getValue(int.class);  // 3
-
-	int oneInt = parser.parseExpression("8 / 5 % 2").getValue(int.class);  // 1
-
-	// -- Exponential power --
-
-	int maxInt = parser.parseExpression("(2^31) - 1").getValue(int.class);  // Integer.MAX_VALUE
-
-	int minInt = parser.parseExpression("-2^31").getValue(int.class);  // Integer.MIN_VALUE
-
-	// -- Operator precedence --
-
-	int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(int.class);  // -21
+	// Operator precedence
+	int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Integer.class);  // -21
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	val inventor = Inventor()
-	val context = SimpleEvaluationContext.forReadWriteDataBinding().build()
+	// Addition
+	val two = parser.parseExpression("1 + 1").getValue(Int::class.java)  // 2

-	// -- Addition --
-
-	var two = parser.parseExpression("1 + 1").getValue(Int::class.java)  // 2
-
-	// -- Subtraction --
+	val testString = parser.parseExpression(
+			"'test' + ' ' + 'string'").getValue(String::class.java)  // 'test string'

+	// Subtraction
 	val four = parser.parseExpression("1 - -3").getValue(Int::class.java)  // 4

 	val d = parser.parseExpression("1000.00 - 1e4").getValue(Double::class.java)  // -9000

-	// -- Increment --
-
-	// The counter property in Inventor has an initial value of 0.
-
-	// evaluates to 2; counter is now 1
-	two = parser.parseExpression("counter++ + 2").getValue(context, inventor, Int::class.java)
-
-	// evaluates to 5; counter is now 2
-	var five = parser.parseExpression("3 + ++counter").getValue(context, inventor, Int::class.java)
-
-	// -- Decrement --
-
-	// The counter property in Inventor has a value of 2.
-
-	// evaluates to 6; counter is now 1
-	var six = parser.parseExpression("counter-- + 4").getValue(context, inventor, Int::class.java)
-
-	// evaluates to 5; counter is now 0
-	five = parser.parseExpression("5 + --counter").getValue(context, inventor, Int::class.java)
-
-	// -- Multiplication --
-
-	six = parser.parseExpression("-2 * -3").getValue(Int::class.java)  // 6
+	// Multiplication
+	val six = parser.parseExpression("-2 * -3").getValue(Int::class.java)  // 6

 	val twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(Double::class.java)  // 24.0

-	// -- Division --
-
+	// Division
 	val minusTwo = parser.parseExpression("6 / -3").getValue(Int::class.java)  // -2

 	val one = parser.parseExpression("8.0 / 4e0 / 2").getValue(Double::class.java)  // 1.0

-	// -- Modulus --
-
+	// Modulus
 	val three = parser.parseExpression("7 % 4").getValue(Int::class.java)  // 3

-	val oneInt = parser.parseExpression("8 / 5 % 2").getValue(Int::class.java)  // 1
-
-	// -- Exponential power --
-
-	val maxInt = parser.parseExpression("(2^31) - 1").getValue(Int::class.java)  // Integer.MAX_VALUE
-
-	val minInt = parser.parseExpression("-2^31").getValue(Int::class.java)  // Integer.MIN_VALUE
-
-	// -- Operator precedence --
+	val one = parser.parseExpression("8 / 5 % 2").getValue(Int::class.java)  // 1

+	// Operator precedence
 	val minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Int::class.java)  // -21	
 ----
 ======
@@ -529,83 +325,3 @@ Kotlin::
 ======


-[[expressions-operators-overloaded]]
-== Overloaded Operators
-
-By default, the mathematical operations defined in SpEL's `Operation` enum (`ADD`,
-`SUBTRACT`, `DIVIDE`, `MULTIPLY`, `MODULUS`, and `POWER`) support simple types like
-numbers. By providing an implementation of `OperatorOverloader`, the expression language
-can support these operations on other types.
-
-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.
-
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	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}`
-as demonstrated in the following example.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	StandardEvaluationContext context = new StandardEvaluationContext();
-	context.setOperatorOverloader(new ListConcatenation());
-
-	// evaluates to a new list: [1, 2, 3, 4, 5]
-	parser.parseExpression("{1, 2, 3} + {2 + 2, 5}").getValue(context, List.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	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)
----
-======
-
-[NOTE]
-====
-An `OperatorOverloader` does not change the default semantics for an operator. For
-example, `2 + 2` in the above example still evaluates to `4`.
-====
-
-[CAUTION]
-====
-Any expression that uses an overloaded operator cannot be compiled. See
-xref:core/expressions/evaluation.adoc#expressions-compiler-limitations[Compiler Limitations]
-for details.
-====
@@ -1,5 +1,5 @@
 [[expressions-templating]]
-= Expression Templating
+= Expression templating

 Expression templates allow mixing literal text with one or more evaluation blocks.
 Each evaluation block is delimited with prefix and suffix characters that you can
@@ -32,13 +32,53 @@ Kotlin::
 ======

 The string is evaluated by concatenating the literal text `'random number is '` with the
-result of evaluating the expression inside the `#{ }` delimiters (in this case, the
-result of calling that `random()` method). The second argument to the `parseExpression()`
-method is of the type `ParserContext`. The `ParserContext` interface is used to influence
-how the expression is parsed in order to support the expression templating functionality.
-The `TemplateParserContext` used in the previous example resides in the
-`org.springframework.expression.common` package and is an implementation of the
-`ParserContext` which by default configures the prefix and suffix to `#{` and `}`,
-respectively.
+result of evaluating the expression inside the `#{ }` delimiter (in this case, the result
+of calling that `random()` method). The second argument to the `parseExpression()` method
+is of the type `ParserContext`. The `ParserContext` interface is used to influence how
+the expression is parsed in order to support the expression templating functionality.
+The definition of `TemplateParserContext` follows:
+
+[tabs]
+======
+Java::
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	public class TemplateParserContext implements ParserContext {
+
+		public String getExpressionPrefix() {
+			return "#{";
+		}
+
+		public String getExpressionSuffix() {
+			return "}";
+		}
+
+		public boolean isTemplate() {
+			return true;
+		}
+	}
+----
+
+Kotlin::
+
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+----
+	class TemplateParserContext : ParserContext {
+
+		override fun getExpressionPrefix(): String {
+			return "#{"
+		}
+
+		override fun getExpressionSuffix(): String {
+			return "}"
+		}
+
+		override fun isTemplate(): Boolean {
+			return true
+		}
+	}
+----
+======


@@ -6,36 +6,15 @@ are set by using the `setVariable()` method in `EvaluationContext` implementatio

 [NOTE]
 ====
-Variable names must be begin with a letter (as defined below), an underscore, or a dollar
-sign.
-
-Variable names must be composed of one or more of the following supported types of
+Valid variable names must be composed of one or more of the following supported
 characters.

-* letter: any character for which `java.lang.Character.isLetter(char)` returns `true`
-  - This includes letters such as `A` to `Z`, `a` to `z`, `ü`, `ñ`, and `é` as well as
-    letters from other character sets such as Chinese, Japanese, Cyrillic, etc.
-* digit: `0` to `9`
+* letters: `A` to `Z` and `a` to `z`
+* digits: `0` to `9`
 * underscore: `_`
 * dollar sign: `$`
 ====

-[TIP]
-====
-When setting a variable or root context object in the `EvaluationContext`, it is advised
-that the type of the variable or root context object be `public`.
-
-Otherwise, certain types of SpEL expressions involving a variable or root context object
-with a non-public type may fail to evaluate or compile.
-====
-
-[WARNING]
-====
-Since variables share a common namespace with
-xref:core/expressions/language-ref/functions.adoc[functions] in the evaluation context,
-care must be taken to ensure that variable names and functions names do not overlap.
-====
-
 The following example shows how to use variables.

 [tabs]
@@ -429,7 +429,7 @@ Kotlin::
 ----
 ======

-A `ConstraintViolation` on `Person.name()` is adapted to a `FieldError` with the following:
+A `ConstraintViolation` on `Person.name()` is adapted to a `FieldErrro` with the following:

 - Error codes `"Size.student.name"`, `"Size.name"`, `"Size.java.lang.String"`, and `"Size"`
 - Message arguments `"name"`, `10`, and `1` (the field name and the constraint attributes)
@@ -717,7 +717,7 @@ For example, with positional parameters:

 	public int countOfActorsByFirstName(String firstName) {
 		return this.jdbcClient.sql("select count(*) from t_actor where first_name = ?")
-				.param(firstName)
+				.param(firstName);
 				.query(Integer.class).single();
 	}
 ----
@@ -730,7 +730,7 @@ For example, with named parameters:

 	public int countOfActorsByFirstName(String firstName) {
 		return this.jdbcClient.sql("select count(*) from t_actor where first_name = :firstName")
-				.param("firstName", firstName)
+				.param("firstName", firstName);
 				.query(Integer.class).single();
 	}
 ----
@@ -759,8 +759,8 @@ With a required single object result:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	Actor actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?")
-			.param(1212L)
+	Actor actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?",
+			.param(1212L);
 			.query(Actor.class)
 			.single();
 ----
@@ -769,8 +769,8 @@ With a `java.util.Optional` result:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	Optional<Actor> actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?")
-			.param(1212L)
+	Optional<Actor> actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?",
+			.param(1212L);
 			.query(Actor.class)
 			.optional();
 ----
@@ -780,7 +780,7 @@ And for an update statement:
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (?, ?)")
-			.param("Leonor").param("Watling")
+			.param("Leonor").param("Watling");
 			.update();
 ----

@@ -789,7 +789,7 @@ Or an update statement with named parameters:
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (:firstName, :lastName)")
-			.param("firstName", "Leonor").param("lastName", "Watling")
+			.param("firstName", "Leonor").param("lastName", "Watling");
 			.update();
 ----

@@ -800,7 +800,7 @@ provides `firstName` and `lastName` properties, such as the `Actor` class from a
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (:firstName, :lastName)")
-			.paramSource(new Actor("Leonor", "Watling")
+			.paramSource(new Actor("Leonor", "Watling");
 			.update();
 ----

@@ -268,8 +268,8 @@ The actual JPA provider bootstrapping is handed off to the specified executor an
 running in parallel, to the application bootstrap thread. The exposed `EntityManagerFactory`
 proxy can be injected into other application components and is even able to respond to
 `EntityManagerFactoryInfo` configuration inspection. However, once the actual JPA provider
-is being accessed by other components (for example, calling `createEntityManager`), those
-calls block until the background bootstrapping has completed. In particular, when you use
+is being accessed by other components (for example, calling `createEntityManager`), those calls
+block until the background bootstrapping has completed. In particular, when you use
 Spring Data JPA, make sure to set up deferred bootstrapping for its repositories as well.


@@ -284,9 +284,9 @@ to a newly created `EntityManager` per operation, in effect making its usage thr

 It is possible to write code against the plain JPA without any Spring dependencies, by
 using an injected `EntityManagerFactory` or `EntityManager`. Spring can understand the
-`@PersistenceUnit` and `@PersistenceContext` annotations both at the field and the method
-level if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example
-shows a plain JPA DAO implementation that uses the `@PersistenceUnit` annotation:
+`@PersistenceUnit` and `@PersistenceContext` annotations both at the field and the method level
+if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example shows a plain
+JPA DAO implementation that uses the `@PersistenceUnit` annotation:

 [tabs]
 ======
@@ -440,8 +440,12 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
+	val tuples: MutableList<Array<Any>> = ArrayList()
+	tuples.add(arrayOf("John", 35))
+	tuples.add(arrayOf("Ann", 50))
+
 	client.sql("SELECT id, name, state FROM table WHERE age IN (:ages)")
-		    .bind("ages", arrayOf(35, 50))
+		    .bind("tuples", arrayOf(35, 50))
 ----
 ======

@@ -38,11 +38,6 @@ within the method.
 A reactive transaction managed by `ReactiveTransactionManager` uses the Reactor context
 instead of thread-local attributes. As a consequence, all participating data access
 operations need to execute within the same Reactor context in the same reactive pipeline.
-
-When configured with a `ReactiveTransactionManager`, all transaction-demarcated methods
-are expected to return a reactive pipeline. Void methods or regular return types need
-to be associated with a regular `PlatformTransactionManager`, e.g. through the
-`transactionManager` attribute of the corresponding `@Transactional` declarations.
 ====

 The following image shows a conceptual view of calling a method on a transactional proxy:
@@ -18,7 +18,7 @@ WebSocket, RSocket.
 xref:integration.adoc[Integration] :: REST Clients, JMS, JCA, JMX,
 Email, Tasks, Scheduling, Caching, Observability, JVM Checkpoint Restore.
 xref:languages.adoc[Languages] :: Kotlin, Groovy, Dynamic Languages.
-xref:appendix.adoc[Appendix] :: Spring properties.
+xref:testing/appendix.adoc[Appendix] :: Spring properties.
 {spring-framework-wiki}[Wiki] :: What's New,
 Upgrade Notes, Supported Versions, additional cross-version information.

@@ -29,7 +29,7 @@ Brannen, Ramnivas Laddad, Arjen Poutsma, Chris Beams, Tareq Abedrabbo, Andy Clem
 Syer, Oliver Gierke, Rossen Stoyanchev, Phillip Webb, Rob Winch, Brian Clozel, Stephane
 Nicoll, Sebastien Deleuze, Jay Bryant, Mark Paluch

-Copyright © 2002 - 2024 VMware, Inc. All Rights Reserved.
+Copyright © 2002 - 2023 VMware, Inc. All Rights Reserved.

 Copies of this document may be made for your own use and for distribution to others,
 provided that you do not charge any fee for such copies and further provided that each
@@ -1,6 +1,5 @@
-[[cds]]
-= CDS
-:page-aliases: integration/class-data-sharing.adoc
+[[class-data-sharing]]
+= Class Data Sharing

 Class Data Sharing (CDS) is a https://docs.oracle.com/en/java/javase/17/vm/class-data-sharing.html[JVM feature]
 that can help reduce the startup time and memory footprint of Java applications.
@@ -85,7 +85,7 @@ email when someone places an order:

 			// Call the collaborators to persist the order...

-			// Create a thread-safe "copy" of the template message and customize it
+			// Create a thread safe "copy" of the template message and customize it
 			SimpleMailMessage msg = new SimpleMailMessage(this.templateMessage);
 			msg.setTo(order.getCustomer().getEmailAddress());
 			msg.setText(
@@ -108,7 +108,7 @@ By default, the following `KeyValues` are created:
 |===
 |Name | Description
 |`code.function` _(required)_|Name of Java `Method` that is scheduled for execution.
-|`code.namespace` _(required)_|Canonical name of the class of the bean instance that holds the scheduled method, or `"ANONYMOUS"` for anonymous classes.
+|`code.namespace` _(required)_|Canonical name of the class of the bean instance that holds the scheduled method.
 |`error` _(required)_|Class name of the exception thrown during the execution, or `"none"` if no exception happened.
 |`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
 |`outcome` _(required)_|Outcome of the method execution. Can be `"SUCCESS"`, `"ERROR"` or `"UNKNOWN"` (if for example the operation was cancelled during execution).
@@ -13,12 +13,12 @@ The Spring Framework provides the following choices for making calls to REST end
 == `RestClient`

 The `RestClient` is a synchronous HTTP client that offers a modern, fluent API.
-It offers an abstraction over HTTP libraries that allows for convenient conversion from a Java object to an HTTP request, and the creation of objects from an HTTP response.
+It offers an abstraction over HTTP libraries that allows for convenient conversion from Java object to HTTP request, and creation of objects from the HTTP response.

 === Creating a `RestClient`

 The `RestClient` is created using one of the static `create` methods.
-You can also use `builder()` to get a builder with further options, such as specifying which HTTP library to use (see <<rest-request-factories>>) and which message converters to use (see <<rest-message-conversion>>), setting a default URI, default path variables, default request headers, or `uriBuilderFactory`, or registering interceptors and initializers.
+You can also use `builder` to get a builder with further options, such as specifying which HTTP library to use (see <<rest-request-factories>>) and which message converters to use (see <<rest-message-conversion>>), setting a default URI, default path variables, a default request headers, or `uriBuilderFactory`, or registering interceptors and initializers.

 Once created (or built), the `RestClient` can be used safely by multiple threads.

@@ -51,9 +51,9 @@ val defaultClient = RestClient.create()

 val customClient = RestClient.builder()
  .requestFactory(HttpComponentsClientHttpRequestFactory())
-  .messageConverters { converters -> converters.add(MyCustomMessageConverter()) }
+  .messageConverters(converters -> converters.add(MyCustomMessageConverter()))
  .baseUrl("https://example.com")
-  .defaultUriVariables(mapOf("variable" to "foo"))
+  .defaultUriVariables(Map.of("variable", "foo"))
  .defaultHeader("My-Header", "Foo")
  .requestInterceptor(myCustomInterceptor)
  .requestInitializer(myCustomInitializer)
@@ -64,36 +64,35 @@ val customClient = RestClient.builder()
 === Using the `RestClient`

 When making an HTTP request with the `RestClient`, the first thing to specify is which HTTP method to use.
-This can be done with `method(HttpMethod)` or with the convenience methods `get()`, `head()`, `post()`, and so on.
+This can be done with `method(HttpMethod)`, or with the convenience methods `get()`, `head()`, `post()`, and so on.

 ==== Request URL

 Next, the request URI can be specified with the `uri` methods.
-This step is optional and can be skipped if the `RestClient` is configured with a default URI.
-The URL is typically specified as a `String`, with optional URI template variables.
+This step is optional, and can be skipped if the `RestClient` is configured with a default URI.
+The URL is typically specified as `String`, with optional URI template variables.
 String URLs are encoded by default, but this can be changed by building a client with a custom `uriBuilderFactory`.

-The URL can also be provided with a function or as a `java.net.URI`, both of which are not encoded.
+The URL can also be provided with a function, or as `java.net.URI`, both of which are not encoded.
 For more details on working with and encoding URIs, see xref:web/webmvc/mvc-uri-building.adoc[URI Links].

 ==== Request headers and body

-If necessary, the HTTP request can be manipulated by adding request headers with `header(String, String)`, `headers(Consumer<HttpHeaders>`, or with the convenience methods `accept(MediaType...)`, `acceptCharset(Charset...)` and so on.
-For HTTP requests that can contain a body (`POST`, `PUT`, and `PATCH`), additional methods are available: `contentType(MediaType)`, and `contentLength(long)`.
+If necessary, the HTTP request can be manipulated, by adding request headers with `header(String, String)`, `headers(Consumer<HttpHeaders>`, or with the convenience methods `accept(MediaType...)`, `acceptCharset(Charset...)` and so on.
+For HTTP request that can contain a body (`POST`, `PUT`, and `PATCH`), additional methods are available: `contentType(MediaType)`, and `contentLength(long)`.

 The request body itself can be set by `body(Object)`, which internally uses <<rest-message-conversion>>.
 Alternatively, the request body can be set using a `ParameterizedTypeReference`, allowing you to use generics.
 Finally, the body can be set to a callback function that writes to an `OutputStream`.

 ==== Retrieving the response
-
 Once the request has been set up, the HTTP response is accessed by invoking `retrieve()`.
-The response body can be accessed by using `body(Class)` or `body(ParameterizedTypeReference)` for parameterized types like lists.
-The `body` method converts the response contents into various types – for instance, bytes can be converted into a `String`, JSON can be converted into objects using Jackson, and so on (see <<rest-message-conversion>>).
+The response body can be accessed by using `body(Class)`, or `body(ParameterizedTypeReference)` for parameterized types like lists.
+The `body` method converts the response contents into various types, for instance bytes can be converted into a `String`, JSON into objects using Jackson, and so on (see <<rest-message-conversion>>).

 The response can also be converted into a `ResponseEntity`, giving access to the response headers as well as the body.

-This sample shows how `RestClient` can be used to perform a simple `GET` request.
+This sample shows how `RestClient` can be used to perform a simple GET request.

 [tabs]
 ======
@@ -172,7 +171,7 @@ println("Contents: " + result.body) <3>
 ======

 `RestClient` can convert JSON to objects, using the Jackson library.
-Note the usage of URI variables in this sample and that the `Accept` header is set to JSON.
+Note the usage of uri variables in this sample, and that the `Accept` header is set to JSON.

 [tabs]
 ======
@@ -249,9 +248,8 @@ val response = restClient.post() <2>
 ======

 ==== Error handling
-
 By default, `RestClient` throws a subclass of `RestClientException` when retrieving a response with a 4xx or 5xx status code.
-This behavior can be overridden using `onStatus`.
+This behavior can be overriden using `onStatus`.

 [tabs]
 ======
@@ -288,9 +286,8 @@ val result = restClient.get() <1>
 ======

 ==== Exchange
-
-For more advanced scenarios, the `RestClient` gives access to the underlying HTTP request and response through the `exchange()` method, which can be used instead of `retrieve()`.
-Status handlers are not applied when use `exchange()`, because the exchange function already provides access to the full response, allowing you to perform any error handling necessary.
+For more advanced scenarios, the `RestClient` gives access to the underlying HTTP request and response through the `exchange` method, which can be used instead of `retrieve()`.
+Status handlers are not applied when you exchange, because the exchange function already provides access to the full response, allowing you to perform any error handling necessary.

 [tabs]
 ======
@@ -339,7 +336,6 @@ val result = restClient.get()

 [[rest-message-conversion]]
 === HTTP Message Conversion
-
 [.small]#xref:web/webflux/reactive-spring.adoc#webflux-codecs[See equivalent in the Reactive stack]#

 The `spring-web` module contains the `HttpMessageConverter` interface for reading and writing the body of HTTP requests and responses through `InputStream` and `OutputStream`.
@@ -401,7 +397,7 @@ By default, this converter supports `text/xml` and `application/xml`.
 |===

 By default, `RestClient` and `RestTemplate` register all built-in message converters, depending on the availability of underlying libraries on the classpath.
-You can also set the message converters to use explicitly, by using the `messageConverters()` method on the `RestClient` builder, or via the `messageConverters` property of `RestTemplate`.
+You can also set the message converters to use explicitly, by using `messageConverters` on the `RestClient` builder, or via the `messageConverters` property of `RestTemplate`.

 ==== Jackson JSON Views

@@ -441,13 +437,13 @@ parts.add("xmlPart", new HttpEntity<>(myBean, headers));
 ----

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

-Once the `MultiValueMap` is ready, you can use it as the body of a `POST` request, using  `RestClient.post().body(parts)` (or `RestTemplate.postForObject`).
+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 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]]
@@ -457,11 +453,11 @@ To execute the HTTP request, `RestClient` uses a client HTTP library.
 These libraries are adapted via the `ClientRequestFactory` interface.
 Various implementations are available:

-* `JdkClientHttpRequestFactory` for Java's `HttpClient`
-* `HttpComponentsClientHttpRequestFactory` for use with Apache HTTP Components `HttpClient`
-* `JettyClientHttpRequestFactory` for Jetty's `HttpClient`
-* `ReactorNettyClientRequestFactory` for Reactor Netty's `HttpClient`
-* `SimpleClientHttpRequestFactory` as a simple default
+* `JdkClientHttpRequestFactory` for Java's `HttpClient`,
+* `HttpComponentsClientHttpRequestFactory` for use with Apache HTTP Components `HttpClient`,
+* `JettyClientHttpRequestFactory` for Jetty's `HttpClient`,
+* `ReactorNettyClientRequestFactory` for Reactor Netty's `HttpClient`,
+* `SimpleClientHttpRequestFactory` as a simple default.


 If no request factory is specified when the `RestClient` was built, it will use the Apache or Jetty `HttpClient` if they are available on the classpath.
@@ -477,12 +473,12 @@ synchronous, asynchronous, and streaming scenarios.

 `WebClient` supports the following:

-* Non-blocking I/O
-* Reactive Streams back pressure
-* High concurrency with fewer hardware resources
-* Functional-style, fluent API that takes advantage of Java 8 lambdas
-* Synchronous and asynchronous interactions
-* Streaming up to or streaming down from a server
+* Non-blocking I/O.
+* Reactive Streams back pressure.
+* High concurrency with fewer hardware resources.
+* Functional-style, fluent API that takes advantage of Java 8 lambdas.
+* Synchronous and asynchronous interactions.
+* Streaming up to or streaming down from a server.

 See xref:web/webflux-webclient.adoc[WebClient] for more details.

@@ -852,17 +848,17 @@ It can be used to migrate from the latter to the former.
 .toEntity(ParameterizedTypeReference)` footnote:request-entity[]


-| `execute(String, HttpMethod, RequestCallback, ResponseExtractor, Object...)`
+| `execute(String, HttpMethod method, RequestCallback, ResponseExtractor, Object...)`
 | `method(HttpMethod)
 .uri(String, Object...)
 .exchange(ExchangeFunction)`

-| `execute(String, HttpMethod, RequestCallback, ResponseExtractor, Map)`
+| `execute(String, HttpMethod method, RequestCallback, ResponseExtractor, Map)`
 | `method(HttpMethod)
 .uri(String, Map)
 .exchange(ExchangeFunction)`

-| `execute(URI, HttpMethod, RequestCallback, ResponseExtractor)`
+| `execute(URI, HttpMethod method, RequestCallback, ResponseExtractor)`
 | `method(HttpMethod)
 .uri(URI)
 .exchange(ExchangeFunction)`
@@ -910,8 +906,8 @@ For `WebClient`:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	WebClient webClient = WebClient.builder().baseUrl("https://api.github.com/").build();
-	WebClientAdapter adapter = WebClientAdapter.create(webClient);
+	WebClient client = WebClient.builder().baseUrl("https://api.github.com/").build();
+	WebClientAdapter adapter = WebClientAdapter.forClient(webClient)
 	HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(adapter).build();

 	RepositoryService service = factory.createClient(RepositoryService.class);
@@ -977,9 +973,6 @@ method parameters:
  `Map<String, ?>` with multiple variables, or an individual value. Type conversion
  is supported for non-String values.

-| `@RequestAttribute`
-| Provide an `Object` to add as a request attribute. Only supported by `WebClient`.
-
 | `@RequestBody`
 | Provide the body of the request either as an Object to be serialized, or a
  Reactive Streams `Publisher` such as `Mono`, `Flux`, or any other async type supported
@@ -1085,34 +1078,11 @@ underlying HTTP client, which operates at a lower level and provides more contro


 [[rest-http-interface-exceptions]]
-=== Error Handling
+=== Exception Handling

-To customize error response handling, you need to configure the underlying HTTP client.
-
-For `RestClient`:
-
-By default, `RestClient` raises `RestClientException` for 4xx and 5xx HTTP status codes.
-To customize this, register a response status handler that applies to all responses
-performed through the client:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	RestClient restClient = RestClient.builder()
-			.defaultStatusHandler(HttpStatusCode::isError, (request, response) -> ...)
-			.build();
-
-	RestClientAdapter adapter = RestClientAdapter.create(restClient);
-	HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(adapter).build();
----
-
-For more details and options, such as suppressing error status codes, see the Javadoc of
-`defaultStatusHandler` in `RestClient.Builder`.
-
-For `WebClient`:
-
-By default, `WebClient` raises `WebClientResponseException` for 4xx and 5xx HTTP status codes.
-To customize this, register a response status handler that applies to all responses
-performed through the client:
+By default, `WebClient` raises `WebClientResponseException` for 4xx and 5xx HTTP status
+codes. To customize this, you can register a response status handler that applies to all
+responses performed through the client:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -1120,28 +1090,10 @@ performed through the client:
 			.defaultStatusHandler(HttpStatusCode::isError, resp -> ...)
 			.build();

-	WebClientAdapter adapter = WebClientAdapter.create(webClient);
-	HttpServiceProxyFactory factory = HttpServiceProxyFactory.builder(adapter).build();
+	WebClientAdapter clientAdapter = WebClientAdapter.forClient(webClient);
+	HttpServiceProxyFactory factory = HttpServiceProxyFactory
+			.builder(clientAdapter).build();
 ----

 For more details and options, such as suppressing error status codes, see the Javadoc of
 `defaultStatusHandler` in `WebClient.Builder`.
-
-For `RestTemplate`:
-
-By default, `RestTemplate` raises `RestClientException` for 4xx and 5xx HTTP status codes.
-To customize this, register an error handler that applies to all responses
-performed through the client:
-
-[source,java,indent=0,subs="verbatim,quotes"]
----
-    RestTemplate restTemplate = new RestTemplate();
-    restTemplate.setErrorHandler(myErrorHandler);
-
-    RestTemplateAdapter adapter = RestTemplateAdapter.create(restTemplate);
-    HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(adapter).build();
----
-
-For more details and options, see the Javadoc of `setErrorHandler` in `RestTemplate` and
-the `ResponseErrorHandler` hierarchy.
-
@@ -252,9 +252,7 @@ application server environments, as well -- in particular on Tomcat and Jetty.
 As of 6.1, `ThreadPoolTaskScheduler` provides a pause/resume capability and graceful
 shutdown through Spring's lifecycle management. There is also a new option called
 `SimpleAsyncTaskScheduler` which is aligned with JDK 21's Virtual Threads, using a
-single scheduler thread but firing up a new thread for every scheduled task execution
-(except for fixed-delay tasks which all operate on a single scheduler thread, so for
-this virtual-thread-aligned option, fixed rates and cron triggers are recommended).
+single scheduler thread but firing up a new thread for every scheduled task execution.



@@ -479,12 +477,12 @@ the framework to invoke a suspending function as a `Publisher`.

 The Spring Framework will obtain a `Publisher` for the annotated method once and will
 schedule a `Runnable` in which it subscribes to said `Publisher`. These inner regular
-subscriptions occur according to the corresponding `cron`/`fixedDelay`/`fixedRate` configuration.
+subscriptions occur according to the corresponding `cron`/fixedDelay`/`fixedRate` configuration.

 If the `Publisher` emits `onNext` signal(s), these are ignored and discarded (the same way
 return values from synchronous `@Scheduled` methods are ignored).

-In the following example, the `Flux` emits `onNext("Hello")`, `onNext("World")` every 5
+In the following example, the `Flux` emits `onNext("Hello"), onNext("World")` every 5
 seconds, but these values are unused:

 [source,java,indent=0,subs="verbatim,quotes"]
@@ -13,7 +13,7 @@ Most of the code samples of the reference documentation are
 provided in Kotlin in addition to Java.

 The easiest way to build a Spring application with Kotlin is to leverage Spring Boot and
-its {spring-boot-docs}/boot-features-kotlin.html[dedicated Kotlin support].
+its{spring-boot-docs}/boot-features-kotlin.html[dedicated Kotlin support].
 {spring-site-guides}/tutorials/spring-boot-kotlin/[This comprehensive tutorial]
 will teach you how to build Spring Boot applications with Kotlin using https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].

@@ -107,7 +107,7 @@ NOTE: Spring Boot is based on JavaConfig and
 {spring-boot-issues}/8115[does not yet provide specific support for functional bean definition],
 but you can experimentally use functional bean definitions through Spring Boot's `ApplicationContextInitializer` support.
 See {stackoverflow-questions}/45935931/how-to-use-functional-bean-definition-kotlin-dsl-with-spring-boot-and-spring-w/46033685#46033685[this Stack Overflow answer]
-for more details and up-to-date information. See also the experimental Kofu DSL developed in {spring-github-org}-experimental/spring-fu[Spring Fu incubator].
+for more details and up-to-date information. See also the experimental Kofu DSL developed in {spring-github-org}/spring-fu[Spring Fu incubator].



@@ -14,10 +14,8 @@ Spring Framework provides support for Coroutines on the following scope:
 * Suspending function support in Spring MVC and WebFlux annotated `@Controller`
 * Extensions for WebFlux {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.client/index.html[client] and {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/index.html[server] functional API.
 * WebFlux.fn {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }] DSL
-* WebFlux {spring-framework-api-kdoc}/spring-web/org.springframework.web.server/-co-web-filter/index.html[`CoWebFilter`]
 * Suspending function and `Flow` support in RSocket `@MessageMapping` annotated methods
 * Extensions for {spring-framework-api-kdoc}/spring-messaging/org.springframework.messaging.rsocket/index.html[`RSocketRequester`]
-* Spring AOP



@@ -10,21 +10,22 @@ The easiest way to learn how to build a Spring application with Kotlin is to fol
 == `start.spring.io`

 The easiest way to start a new Spring Framework project in Kotlin is to create a new Spring
-Boot project on https://start.spring.io/#!language=kotlin&type=gradle-project-kotlin[start.spring.io].
+Boot 2 project on https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].



 [[choosing-the-web-flavor]]
 == Choosing the Web Flavor

-Spring Framework comes with two different web stacks: xref:web/webmvc.adoc#mvc[Spring MVC] and
+Spring Framework now comes with two different web stacks: xref:web/webmvc.adoc#mvc[Spring MVC] and
 xref:testing/unit.adoc#mock-objects-web-reactive[Spring WebFlux].

 Spring WebFlux is recommended if you want to create applications that will deal with latency,
-long-lived connections or streaming scenarios.
+long-lived connections, streaming scenarios or if you want to use the web functional
+Kotlin DSL.

 For other use cases, especially if you are using blocking technologies such as JPA, Spring
-MVC is the recommended choice.
+MVC and its annotation-based programming model is the recommended choice.



@@ -2,12 +2,15 @@
 = Requirements
 :page-section-summary-toc: 1

-Spring Framework supports Kotlin 1.7+ and requires
+Spring Framework supports Kotlin 1.3+ and requires
 https://search.maven.org/artifact/org.jetbrains.kotlin/kotlin-stdlib[`kotlin-stdlib`]
+(or one of its variants, such as https://search.maven.org/artifact/org.jetbrains.kotlin/kotlin-stdlib-jdk8[`kotlin-stdlib-jdk8`])
 and https://search.maven.org/artifact/org.jetbrains.kotlin/kotlin-reflect[`kotlin-reflect`]
 to be present on the classpath. They are provided by default if you bootstrap a Kotlin project on
 https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].

+WARNING: Kotlin {kotlin-docs}/inline-classes.html[inline classes] are not yet supported.
+
 NOTE: The {jackson-github-org}/jackson-module-kotlin[Jackson Kotlin module] is required
 for serializing or deserializing JSON data for Kotlin classes with Jackson, so make sure to add the
 `com.fasterxml.jackson.module:jackson-module-kotlin` dependency to your project if you have such need.
@@ -18,9 +18,28 @@ Kotlin and the Spring Framework:

 The following Github projects offer examples that you can learn from and possibly even extend:

-* https://github.com/spring-guides/tut-spring-boot-kotlin[tut-spring-boot-kotlin]: Sources of {spring-site}/guides/tutorials/spring-boot-kotlin/[the official Spring + Kotlin tutorial]
 * https://github.com/sdeleuze/spring-boot-kotlin-demo[spring-boot-kotlin-demo]: Regular Spring Boot and Spring Data JPA project
-* https://github.com/mixitconf/mixit[mixit]: Spring Boot, WebFlux, and Reactive Spring Data MongoDB
+* https://github.com/mixitconf/mixit[mixit]: Spring Boot 2, WebFlux, and Reactive Spring Data MongoDB
 * https://github.com/sdeleuze/spring-kotlin-functional[spring-kotlin-functional]: Standalone WebFlux and functional bean definition DSL
 * https://github.com/sdeleuze/spring-kotlin-fullstack[spring-kotlin-fullstack]: WebFlux Kotlin fullstack example with Kotlin2js for frontend instead of JavaScript or TypeScript
 * https://github.com/spring-petclinic/spring-petclinic-kotlin[spring-petclinic-kotlin]: Kotlin version of the Spring PetClinic Sample Application
+* https://github.com/sdeleuze/spring-kotlin-deepdive[spring-kotlin-deepdive]: A step-by-step migration guide for Boot 1.0 and Java to Boot 2.0 and Kotlin
+* https://github.com/spring-cloud/spring-cloud-gcp/tree/master/spring-cloud-gcp-kotlin-samples/spring-cloud-gcp-kotlin-app-sample[spring-cloud-gcp-kotlin-app-sample]: Spring Boot with Google Cloud Platform Integrations
+
+
+
+[[issues]]
+== Issues
+
+The following list categorizes the pending issues related to Spring and Kotlin support:
+
+* Spring Framework
+** {spring-framework-issues}/20606[Unable to use WebTestClient with mock server in Kotlin]
+** {spring-framework-issues}/20496[Support null-safety at generics, varargs and array elements level]
+* Kotlin
+** {kotlin-issues}/KT-6380[Parent issue for Spring Framework support]
+** {kotlin-issues}/KT-5464[Kotlin requires type inference where Java doesn't]
+** {kotlin-issues}/KT-20283[Smart cast regression with open classes]
+** {kotlin-issues}/KT-14984[Impossible to pass not all SAM argument as function]
+** {kotlin-issues}/KT-15125[Support JSR 223 bindings directly via script variables]
+** {kotlin-issues}/KT-6653[Kotlin properties do not override Java-style getters and setters]
@@ -9,7 +9,7 @@ in Kotlin.
 [[final-by-default]]
 == Final by Default

-By default, https://discuss.kotlinlang.org/t/classes-final-by-default/166[all classes and member functions in Kotlin are `final`].
+By default, https://discuss.kotlinlang.org/t/classes-final-by-default/166[all classes in Kotlin are `final`].
 The `open` modifier on a class is the opposite of Java's `final`: It allows others to inherit from this
 class. This also applies to member functions, in that they need to be marked as `open` to be overridden.

@@ -38,12 +38,6 @@ Meta-annotation support means that types annotated with `@Configuration`, `@Cont
 `@RestController`, `@Service`, or `@Repository` are automatically opened since these
 annotations are meta-annotated with `@Component`.

-WARNING: Some use cases involving proxies and automatic generation of final methods by the Kotlin compiler require extra
-care. For example, a Kotlin class with properties will generate related `final` getters and setters. In order
-to be able to proxy related methods, a type level `@Component` annotation should be preferred to method level `@Bean` in
-order to have those methods opened by the `kotlin-spring` plugin. A typical use case is `@Scope` and its popular
-`@RequestScope` specialization.
-
 https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io] enables
 the `kotlin-spring` plugin by default. So, in practice, you can write your Kotlin beans
 without any additional `open` keyword, as in Java.
@@ -103,9 +97,6 @@ does not require the `kotlin-noarg` plugin if the module uses Spring Data object
 [[injecting-dependencies]]
 == Injecting Dependencies

-[[favor-constructor-injection]]
-=== Favor constructor injection
-
 Our recommendation is to try to favor constructor injection with `val` read-only (and
 non-nullable when possible) {kotlin-docs}/properties.html[properties],
 as the following example shows:
@@ -139,41 +130,7 @@ as the following example shows:
 	}
 ----

-[[internal-functions-name-mangling]]
-=== Internal functions name mangling

-Kotlin functions with the `internal` {kotlin-docs}/visibility-modifiers.html#class-members[visibility modifier] have
-their names mangled when compiled to JVM bytecode, which has a side effect when injecting dependencies by name.
-
-For example, this Kotlin class:
-[source,kotlin,indent=0]
----
-@Configuration
-class SampleConfiguration {
-
-	@Bean
-	internal fun sampleBean() = SampleBean()
-}
----
-
-Translates to this Java representation of the compiled JVM bytecode:
-[source,java,indent=0]
----
-@Configuration
-@Metadata(/* ... */)
-public class SampleConfiguration {
-
-	@Bean
-	@NotNull
-	public SampleBean sampleBean$demo_kotlin_internal_test() {
-        return new SampleBean();
-	}
-}
----
-
-As a consequence, the related bean name represented as a Kotlin string is `"sampleBean\$demo_kotlin_internal_test"`,
-instead of `"sampleBean"` for the regular `public` function use-case. Make sure to use the mangled name when injecting
-such bean by name, or add `@JvmName("sampleBean")` to disable name mangling.

 [[injecting-configuration-properties]]
 == Injecting Configuration Properties
@@ -8,9 +8,9 @@

 Spring Framework comes with a Kotlin router DSL available in 3 flavors:

-* xref:web/webmvc-functional.adoc[WebMvc.fn DSL] with {spring-framework-api-kdoc}/spring-webmvc/org.springframework.web.servlet.function/router.html[router { }]
-* xref:web/webflux-functional.adoc[WebFlux.fn Reactive DSL] with {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/router.html[router { }]
-* xref:languages/kotlin/coroutines.adoc[WebFlux.fn Coroutines DSL] with {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }]
+* WebMvc.fn DSL with {spring-framework-api-kdoc}/spring-webmvc/org.springframework.web.servlet.function/router.html[router { }]
+* WebFlux.fn <<web-reactive#webflux-fn, Reactive>> DSL with {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/router.html[router { }]
+* WebFlux.fn <<Coroutines>> DSL with {spring-framework-api-kdoc}/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }]

 These DSL let you write clean and idiomatic Kotlin code to build a `RouterFunction` instance as the following example shows:

@@ -126,7 +126,7 @@ project for more details.
 [[kotlin-multiplatform-serialization]]
 == Kotlin multiplatform serialization

-{kotlin-github-org}/kotlinx.serialization[Kotlin multiplatform serialization] is
+As of Spring Framework 5.3, {kotlin-github-org}/kotlinx.serialization[Kotlin multiplatform serialization] is
 supported in Spring MVC, Spring WebFlux and Spring Messaging (RSocket). The builtin support currently targets CBOR, JSON, and ProtoBuf formats.

 To enable it, follow {kotlin-github-org}/kotlinx.serialization#setup[those instructions] to add the related dependency and plugin.
@@ -152,7 +152,7 @@ Kotlin::
 		@Autowired
 		lateinit var accountService: AccountService

-		lateinit var mockMvc: MockMvc
+		lateinit mockMvc: MockMvc

 		@BeforeEach
 		fun setup(wac: WebApplicationContext) {
@@ -782,73 +782,6 @@ Kotlin::
 ======


-[[webflux-fn-serving-resources]]
-== Serving Resources
-
-WebFlux.fn provides built-in support for serving resources.
-
-NOTE: In addition to the capabilities described below, it is possible to implement even more flexible resource handling thanks to
-{spring-framework-api}++/web/reactive/function/server/RouterFunctions.html#resources(java.util.function.Function)++[`RouterFunctions#resource(java.util.function.Function)`].
-
-[[webflux-fn-resource]]
-=== Redirecting to a resource
-
-It is possible to redirect requests matching a specified predicate to a resource. This can be useful, for example,
-for handling redirects in Single Page Applications.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ClassPathResource index = new ClassPathResource("static/index.html");
-	List<String> extensions = Arrays.asList("js", "css", "ico", "png", "jpg", "gif");
-	RequestPredicate spaPredicate = path("/api/**").or(path("/error")).or(pathExtension(extensions::contains)).negate();
-	RouterFunction<ServerResponse> redirectToIndex = route()
-		.resource(spaPredicate, index)
-		.build();
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val redirectToIndex = router {
-		val index = ClassPathResource("static/index.html")
-		val extensions = listOf("js", "css", "ico", "png", "jpg", "gif")
-		val spaPredicate = !(path("/api/**") or path("/error") or
-			pathExtension(extensions::contains))
-		resource(spaPredicate, index)
-	}
----
-======
-
-[[webflux-fn-resources]]
-=== Serving resources from a root location
-
-It is also possible to route requests that match a given pattern to resources relative to a given root location.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-    Resource location = new FileSystemResource("public-resources/");
-    RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-    val location = FileSystemResource("public-resources/")
-    val resources = router { resources("/resources/**", location) }
----
-======
-
-
 [[webflux-fn-running]]
 == Running a Server
 [.small]#xref:web/webmvc-functional.adoc#webmvc-fn-running[See equivalent in the Servlet stack]#
@@ -28,12 +28,6 @@ because, arguably, most controller methods should be mapped to a specific HTTP m
 using `@RequestMapping`, which, by default, matches to all HTTP methods. At the same time, a
 `@RequestMapping` is still needed at the class level to express shared mappings.

-NOTE: `@RequestMapping` cannot be used in conjunction with other `@RequestMapping`
-annotations that are declared on the same element (class, interface, or method). If
-multiple `@RequestMapping` annotations are detected on the same element, a warning will
-be logged, and only the first mapping will be used. This also applies to composed
-`@RequestMapping` annotations such as `@GetMapping`, `@PostMapping`, etc.
-
 The following example uses type and method level mappings:

 [tabs]
@@ -442,14 +436,8 @@ attributes with a narrower, more specific purpose.
 `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`, and `@PatchMapping` are
 examples of composed annotations. They are provided, because, arguably, most
 controller methods should be mapped to a specific HTTP method versus using `@RequestMapping`,
-which, by default, matches to all HTTP methods. If you need an example of how to implement
-a composed annotation, look at how those are declared.
-
-NOTE: `@RequestMapping` cannot be used in conjunction with other `@RequestMapping`
-annotations that are declared on the same element (class, interface, or method). If
-multiple `@RequestMapping` annotations are detected on the same element, a warning will
-be logged, and only the first mapping will be used. This also applies to composed
-`@RequestMapping` annotations such as `@GetMapping`, `@PostMapping`, etc.
+which, by default, matches to all HTTP methods. If you need an example of composed
+annotations, look at how those are declared.

 Spring WebFlux also supports custom request mapping attributes with custom request matching
 logic. This is a more advanced option that requires sub-classing
@@ -523,17 +511,10 @@ Kotlin::
 == `@HttpExchange`
 [.small]#xref:web/webmvc/mvc-controller/ann-requestmapping.adoc#mvc-ann-httpexchange-annotation[See equivalent in the Servlet stack]#

-While the main purpose of `@HttpExchange` is to abstract HTTP client code with a
-generated proxy, the
-xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] on which
-such annotations are placed is a contract neutral to client vs server use.
-In addition to simplifying client code, there are also cases where an HTTP Interface
-may be a convenient way for servers to expose their API for client access. This leads
-to increased coupling between client and server and is often not a good choice,
-especially for public API's, but may be exactly the goal for an internal API.
-It is an approach commonly used in Spring Cloud, and it is why `@HttpExchange` is
-supported as an alternative to `@RequestMapping` for server side handling in
-controller classes.
+As an alternative to  `@RequestMapping`, you can also handle requests with `@HttpExchange`
+methods. Such methods are declared on an
+xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] and can be used as
+a client via `HttpServiceProxyFactory` or implemented by a server `@Controller`.

 For example:

@@ -543,23 +524,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
+	@RestController
 	@HttpExchange("/persons")
-	interface PersonService {
+	class PersonController {

 		@GetExchange("/{id}")
-		Person getPerson(@PathVariable Long id);
-
-		@PostExchange
-		void add(@RequestBody Person person);
-	}
-
-	@RestController
-	class PersonController implements PersonService {
-
 		public Person getPerson(@PathVariable Long id) {
 			// ...
 		}

+		@PostExchange
 		@ResponseStatus(HttpStatus.CREATED)
 		public void add(@RequestBody Person person) {
 			// ...
@@ -571,38 +545,30 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
+	@RestController
 	@HttpExchange("/persons")
-	interface PersonService {
+	class PersonController {

 		@GetExchange("/{id}")
-		fun getPerson(@PathVariable id: Long): Person
-
-		@PostExchange
-		fun add(@RequestBody person: Person)
-	}
-
-	@RestController
-	class PersonController : PersonService {
-
-		override fun getPerson(@PathVariable id: Long): Person {
+		fun getPerson(@PathVariable id: Long): Person {
 			// ...
 		}

+		@PostExchange
 		@ResponseStatus(HttpStatus.CREATED)
-		override fun add(@RequestBody person: Person) {
+		fun add(@RequestBody person: Person) {
 			// ...
 		}
 	}
 ----
 ======

-`@HttpExchange` and `@RequestMapping` have differences.
-`@RequestMapping` can map to any number of requests by path patterns, HTTP methods,
-and more, while `@HttpExchange` declares a single endpoint with a concrete HTTP method,
-path, and content types.
-
-For method parameters and returns values, generally, `@HttpExchange` supports a
-subset of the method parameters that `@RequestMapping` does. Notably, it excludes any
-server-side specific parameter types. For details, see the list for
-xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[@HttpExchange] and
+There some differences between `@HttpExchange` and `@RequestMapping` since the
+former needs to remain suitable for client and server use. For example, while
+`@RequestMapping` can be declared to handle any number of paths and each path can
+be a pattern, `@HttpExchange` must be declared with a single, concrete path. There are
+also differences in the supported method parameters. Generally, `@HttpExchange` supports
+a subset of method parameters that `@RequestMapping` does, excluding any parameters that
+are server side only. For details see the list of supported method parameters for
+xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[HTTP interface] and for
 xref:web/webflux/controller/ann-methods/arguments.adoc[@RequestMapping].
@@ -8,23 +8,22 @@ Spring WebFlux has built-in xref:core/validation/validator.adoc[Validation] supp
 xref:core/validation/beanvalidation.adoc[Java Bean Validation].
 The validation support works on two levels.

-First, resolvers for
+First, method parameters such as
 xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
 xref:web/webflux/controller/ann-methods/requestbody.adoc[@RequestBody], and
-xref:web/webflux/controller/ann-methods/multipart-forms.adoc[@RequestPart] method
-parameters perform validation if the parameter has Jakarta's `@Valid` or Spring's
-`@Validated` annotation, and raise `MethodArgumentNotValidException` if necessary.
-Alternatively, you can handle the errors in the controller method by adding an
-`Errors` or `BindingResult` method parameter immediately after the validated one.
+xref:web/webflux/controller/ann-methods/multipart-forms.adoc[@RequestPart] do perform
+validation if annotated with Jakarta's `@Valid` or Spring's `@Validated` annotation, and
+raise `MethodArgumentNotValidException` in case of validation errors. If you want to handle
+the errors in the controller method instead, you can declare an `Errors` or `BindingResult`
+method parameter immediately after the validated parameter.

-Second, if {bean-validation-site}[Java Bean Validation] is present _AND_ any method
-parameter has `@Constraint` annotations, then method validation is applied instead,
-raising `HandlerMethodValidationException` if necessary. For this case you can still add
-an `Errors` or `BindingResult` method parameter to handle validation errors within the
-controller method, but if other method arguments have validation errors then
-`HandlerMethodValidationException` is raised instead. Method validation can apply
-to the return value if the method is annotated with `@Valid` or with `@Constraint`
-annotations.
+Second, if {bean-validation-site}[Java Bean Validation] is present _AND_ other method
+parameters, e.g. `@RequestHeader`, `@RequestParam`, `@PathVariable` have `@Constraint`
+annotations, then method validation is applied to all method arguments, raising
+`HandlerMethodValidationException` in case of validation errors. You can still declare an
+`Errors` or `BindingResult` after an `@Valid` method parameter, and handle validation
+errors within the controller method, as long as there are no validation errors on other
+method arguments.

 You can configure a `Validator` globally through the
 xref:web/webflux/config.adoc#webflux-config-validation[WebMvc config], or locally
@@ -760,73 +760,6 @@ Kotlin::
 ======


-[[webmvc-fn-serving-resources]]
-== Serving Resources
-
-WebMvc.fn provides built-in support for serving resources.
-
-NOTE: In addition to the capabilities described below, it is possible to implement even more flexible resource handling thanks to
-{spring-framework-api}++/web/servlet/function/RouterFunctions.html#resources(java.util.function.Function)++[`RouterFunctions#resource(java.util.function.Function)`].
-
-[[webmvc-fn-resource]]
-=== Redirecting to a resource
-
-It is possible to redirect requests matching a specified predicate to a resource. This can be useful, for example,
-for handling redirects in Single Page Applications.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-    ClassPathResource index = new ClassPathResource("static/index.html");
-	List<String> extensions = Arrays.asList("js", "css", "ico", "png", "jpg", "gif");
-	RequestPredicate spaPredicate = path("/api/**").or(path("/error")).or(pathExtension(extensions::contains)).negate();
-	RouterFunction<ServerResponse> redirectToIndex = route()
-		.resource(spaPredicate, index)
-		.build();
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-    val redirectToIndex = router {
-		val index = ClassPathResource("static/index.html")
-		val extensions = listOf("js", "css", "ico", "png", "jpg", "gif")
-		val spaPredicate = !(path("/api/**") or path("/error") or
-			pathExtension(extensions::contains))
-		resource(spaPredicate, index)
-	}
----
-======
-
-[[webmvc-fn-resources]]
-=== Serving resources from a root location
-
-It is also possible to route requests that match a given pattern to resources relative to a given root location.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-    Resource location = new FileSystemResource("public-resources/");
-    RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-    val location = FileSystemResource("public-resources/")
-    val resources = router { resources("/resources/**", location) }
----
-======
-
-
 [[webmvc-fn-running]]
 == Running a Server
 [.small]#xref:web/webflux-functional.adoc#webflux-fn-running[See equivalent in the Reactive stack]#
@@ -78,9 +78,8 @@ it does the same, but it also compares the computed value against the `If-None-M
 request header and, if the two are equal, returns a 304 (NOT_MODIFIED).

 This strategy saves network bandwidth but not CPU, as the full response must be computed for each request.
-State-changing HTTP methods and other HTTP conditional request headers such as `If-Match` and
-`If-Unmodified-Since` are outside the scope of this filter. Other strategies at the controller level
-can avoid the computation and have a broader support for HTTP conditional requests.
+State-changing HTTP methods and other HTTP conditional request headers such as `If-Match` and `If-Unmodified-Since` are outside the scope of this filter.
+Other strategies at the controller level can avoid the computation and have a broader support for HTTP conditional requests.
 See xref:web/webmvc/mvc-caching.adoc[HTTP Caching].

 This filter has a `writeWeakETag` parameter that configures the filter to write weak ETags
@@ -30,12 +30,6 @@ arguably, most controller methods should be mapped to a specific HTTP method ver
 using `@RequestMapping`, which, by default, matches to all HTTP methods.
 A `@RequestMapping` is still needed at the class level to express shared mappings.

-NOTE: `@RequestMapping` cannot be used in conjunction with other `@RequestMapping`
-annotations that are declared on the same element (class, interface, or method). If
-multiple `@RequestMapping` annotations are detected on the same element, a warning will
-be logged, and only the first mapping will be used. This also applies to composed
-`@RequestMapping` annotations such as `@GetMapping`, `@PostMapping`, etc.
-
 The following example has type and method level mappings:

 [tabs]
@@ -468,6 +462,11 @@ transparently for request mapping. Controller methods do not need to change.
 A response wrapper, applied in `jakarta.servlet.http.HttpServlet`, ensures a `Content-Length`
 header is set to the number of bytes written (without actually writing to the response).

+`@GetMapping` (and `@RequestMapping(method=HttpMethod.GET)`) are implicitly mapped to
+and support HTTP HEAD. An HTTP HEAD request is processed as if it were HTTP GET except
+that, instead of writing the body, the number of bytes are counted and the `Content-Length`
+header is set.
+
 By default, HTTP OPTIONS is handled by setting the `Allow` response header to the list of HTTP
 methods listed in all `@RequestMapping` methods that have matching URL patterns.

@@ -492,14 +491,8 @@ attributes with a narrower, more specific purpose.
 `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`, and `@PatchMapping` are
 examples of composed annotations. They are provided because, arguably, most
 controller methods should be mapped to a specific HTTP method versus using `@RequestMapping`,
-which, by default, matches to all HTTP methods. If you need an example of how to implement
-a composed annotation, look at how those are declared.
-
-NOTE: `@RequestMapping` cannot be used in conjunction with other `@RequestMapping`
-annotations that are declared on the same element (class, interface, or method). If
-multiple `@RequestMapping` annotations are detected on the same element, a warning will
-be logged, and only the first mapping will be used. This also applies to composed
-`@RequestMapping` annotations such as `@GetMapping`, `@PostMapping`, etc.
+which, by default, matches to all HTTP methods. If you need an example of composed
+annotations, look at how those are declared.

 Spring MVC also supports custom request-mapping attributes with custom request-matching
 logic. This is a more advanced option that requires subclassing
@@ -569,17 +562,10 @@ Kotlin::
 == `@HttpExchange`
 [.small]#xref:web/webflux/controller/ann-requestmapping.adoc#webflux-ann-httpexchange-annotation[See equivalent in the Reactive stack]#

-While the main purpose of `@HttpExchange` is to abstract HTTP client code with a
-generated proxy, the
-xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] on which
-such annotations are placed is a contract neutral to client vs server use.
-In addition to simplifying client code, there are also cases where an HTTP Interface
-may be a convenient way for servers to expose their API for client access. This leads
-to increased coupling between client and server and is often not a good choice,
-especially for public API's, but may be exactly the goal for an internal API.
-It is an approach commonly used in Spring Cloud, and it is why `@HttpExchange` is
-supported as an alternative to `@RequestMapping` for server side handling in
-controller classes.
+As an alternative to  `@RequestMapping`, you can also handle requests with `@HttpExchange`
+methods. Such methods are declared on an
+xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] and can be used as
+a client via `HttpServiceProxyFactory` or implemented by a server `@Controller`.

 For example:

@@ -589,23 +575,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
+	@RestController
 	@HttpExchange("/persons")
-	interface PersonService {
+	class PersonController {

 		@GetExchange("/{id}")
-		Person getPerson(@PathVariable Long id);
-
-		@PostExchange
-		void add(@RequestBody Person person);
-	}
-
-	@RestController
-	class PersonController implements PersonService {
-
 		public Person getPerson(@PathVariable Long id) {
 			// ...
 		}

+		@PostExchange
 		@ResponseStatus(HttpStatus.CREATED)
 		public void add(@RequestBody Person person) {
 			// ...
@@ -617,38 +596,30 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
+	@RestController
 	@HttpExchange("/persons")
-	interface PersonService {
+	class PersonController {

 		@GetExchange("/{id}")
-		fun getPerson(@PathVariable id: Long): Person
-
-		@PostExchange
-		fun add(@RequestBody person: Person)
-	}
-
-	@RestController
-	class PersonController : PersonService {
-
-		override fun getPerson(@PathVariable id: Long): Person {
+		fun getPerson(@PathVariable id: Long): Person {
 			// ...
 		}

+		@PostExchange
 		@ResponseStatus(HttpStatus.CREATED)
-		override fun add(@RequestBody person: Person) {
+		fun add(@RequestBody person: Person) {
 			// ...
 		}
 	}
 ----
 ======

-`@HttpExchange` and `@RequestMapping` have differences.
-`@RequestMapping` can map to any number of requests by path patterns, HTTP methods,
-and more, while `@HttpExchange` declares a single endpoint with a concrete HTTP method,
-path, and content types.
-
-For method parameters and returns values, generally, `@HttpExchange` supports a
-subset of the method parameters that `@RequestMapping` does. Notably, it excludes any
-server-side specific parameter types. For details, see the list for
-xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[@HttpExchange] and
+There some differences between `@HttpExchange` and `@RequestMapping` since the
+former needs to remain suitable for client and server use. For example, while
+`@RequestMapping` can be declared to handle any number of paths and each path can
+be a pattern, `@HttpExchange` must be declared with a single, concrete path. There are
+also differences in the supported method parameters. Generally, `@HttpExchange` supports
+a subset of method parameters that `@RequestMapping` does, excluding any parameters that
+are server side only. For details see the list of supported method parameters for
+xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[HTTP interface] and for
 xref:web/webmvc/mvc-controller/ann-methods/arguments.adoc[@RequestMapping].
@@ -8,23 +8,23 @@ Spring MVC has built-in xref:core/validation/validator.adoc[Validation] support
 xref:core/validation/beanvalidation.adoc[Java Bean Validation].
 The validation support works on two levels.

-First, resolvers for
+First, method parameters such as
 xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
 xref:web/webmvc/mvc-controller/ann-methods/requestbody.adoc[@RequestBody], and
-xref:web/webmvc/mvc-controller/ann-methods/multipart-forms.adoc[@RequestPart] method
-parameters perform validation if the parameter has Jakarta's `@Valid` or Spring's
-`@Validated` annotation, and raise `MethodArgumentNotValidException` if necessary.
-Alternatively, you can handle the errors in the controller method by adding an
-`Errors` or `BindingResult` method parameter immediately after the validated one.
+xref:web/webmvc/mvc-controller/ann-methods/multipart-forms.adoc[@RequestPart] do perform
+validation if annotated with Jakarta's `@Valid` or Spring's `@Validated` annotation, and
+raise `MethodArgumentNotValidException` in case of validation errors. If you want to handle
+the errors in the controller method instead, you can declare an `Errors` or `BindingResult`
+method parameter immediately after the validated parameter.

-Second, if {bean-validation-site}[Java Bean Validation] is present _AND_ any method
-parameter has `@Constraint` annotations, then method validation is applied instead,
-raising `HandlerMethodValidationException` if necessary. For this case you can still add
-an `Errors` or `BindingResult` method parameter to handle validation errors within the
-controller method, but if other method arguments have validation errors then
-`HandlerMethodValidationException` is raised instead. Method validation can apply
-to the return value if the method is annotated with `@Valid` or with `@Constraint`
-annotations.
+Second, if {bean-validation-site}[Java Bean Validation] is present _AND_ other method
+parameters, e.g. `@RequestHeader`, `@RequestParam`, `@PathVariable` have `@Constraint`
+annotations, then method validation is applied to all method arguments, raising
+`HandlerMethodValidationException` in case of validation errors. You can still declare an
+`Errors` or `BindingResult` after an `@Valid` method parameter, and handle validation
+errors within the controller method, as long as there are no validation errors on other
+method arguments. Method validation is also applied to the return value if the method
+is annotated with `@Valid` or has other `@Constraint` annotations.

 You can configure a `Validator` globally through the
 xref:web/webmvc/mvc-config/validation.adoc[WebMvc config], or locally through an
@@ -109,4 +109,4 @@ Kotlin::
        }
 	})
 ----
-======
+======
@@ -38,7 +38,7 @@ The next example uses server-side configuration to register a custom authenticat
 interceptor. Note that an interceptor needs only to authenticate and set
 the user header on the CONNECT `Message`. Spring notes and saves the authenticated
 user and associate it with subsequent STOMP messages on the same session. The following
-example shows how to register a custom authentication interceptor:
+example shows how register a custom authentication interceptor:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -24,7 +24,7 @@ import org.springframework.aot.hint.predicate.RuntimeHintsPredicates;

 import static org.assertj.core.api.Assertions.assertThat;

-class SpellCheckServiceTests {
+public class SpellCheckServiceTests {

 	// tag::hintspredicates[]
 	@Test
@@ -7,33 +7,32 @@ javaPlatform {
 }

 dependencies {
-	api(platform("com.fasterxml.jackson:jackson-bom:2.15.4"))
-	api(platform("io.micrometer:micrometer-bom:1.12.4"))
-	api(platform("io.netty:netty-bom:4.1.107.Final"))
+	api(platform("com.fasterxml.jackson:jackson-bom:2.15.2"))
+	api(platform("io.micrometer:micrometer-bom:1.12.1"))
+	api(platform("io.netty:netty-bom:4.1.101.Final"))
 	api(platform("io.netty:netty5-bom:5.0.0.Alpha5"))
-	api(platform("io.projectreactor:reactor-bom:2023.0.4"))
+	api(platform("io.projectreactor:reactor-bom:2023.0.1"))
 	api(platform("io.rsocket:rsocket-bom:1.1.3"))
-	api(platform("org.apache.groovy:groovy-bom:4.0.19"))
+	api(platform("org.apache.groovy:groovy-bom:4.0.16"))
 	api(platform("org.apache.logging.log4j:log4j-bom:2.21.1"))
-	api(platform("org.assertj:assertj-bom:3.25.3"))
-	api(platform("org.eclipse.jetty:jetty-bom:12.0.7"))
-	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.7"))
+	api(platform("org.eclipse.jetty:jetty-bom:12.0.4"))
+	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.3"))
 	api(platform("org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.7.3"))
 	api(platform("org.jetbrains.kotlinx:kotlinx-serialization-bom:1.6.0"))
-	api(platform("org.junit:junit-bom:5.10.2"))
-	api(platform("org.mockito:mockito-bom:5.11.0"))
+	api(platform("org.junit:junit-bom:5.10.1"))
+	api(platform("org.mockito:mockito-bom:5.8.0"))

 	constraints {
 		api("com.fasterxml:aalto-xml:1.3.2")
-		api("com.fasterxml.woodstox:woodstox-core:6.6.1")
+		api("com.fasterxml.woodstox:woodstox-core:6.5.1")
 		api("com.github.ben-manes.caffeine:caffeine:3.1.8")
-		api("com.github.librepdf:openpdf:1.3.42")
+		api("com.github.librepdf:openpdf:1.3.33")
 		api("com.google.code.findbugs:findbugs:3.0.1")
 		api("com.google.code.findbugs:jsr305:3.0.2")
 		api("com.google.code.gson:gson:2.10.1")
-		api("com.google.protobuf:protobuf-java-util:3.25.3")
+		api("com.google.protobuf:protobuf-java-util:3.25.0")
 		api("com.h2database:h2:2.2.224")
-		api("com.jayway.jsonpath:json-path:2.9.0")
+		api("com.jayway.jsonpath:json-path:2.8.0")
 		api("com.rometools:rome:1.19.0")
 		api("com.squareup.okhttp3:mockwebserver:3.14.9")
 		api("com.squareup.okhttp3:okhttp:3.14.9")
@@ -42,11 +41,11 @@ dependencies {
 		api("com.sun.xml.bind:jaxb-core:3.0.2")
 		api("com.sun.xml.bind:jaxb-impl:3.0.2")
 		api("com.sun.xml.bind:jaxb-xjc:3.0.2")
-		api("com.thoughtworks.qdox:qdox:2.1.0")
+		api("com.thoughtworks.qdox:qdox:2.0.3")
 		api("com.thoughtworks.xstream:xstream:1.4.20")
 		api("commons-io:commons-io:2.15.0")
 		api("de.bechte.junit:junit-hierarchicalcontextrunner:4.12.2")
-		api("io.micrometer:context-propagation:1.1.1")
+		api("io.micrometer:context-propagation:1.1.0")
 		api("io.mockk:mockk:1.13.4")
 		api("io.projectreactor.netty:reactor-netty5-http:2.0.0-M3")
 		api("io.projectreactor.tools:blockhound:1.0.8.RELEASE")
@@ -55,9 +54,9 @@ dependencies {
 		api("io.r2dbc:r2dbc-spi:1.0.0.RELEASE")
 		api("io.reactivex.rxjava3:rxjava:3.1.8")
 		api("io.smallrye.reactive:mutiny:1.10.0")
-		api("io.undertow:undertow-core:2.3.12.Final")
-		api("io.undertow:undertow-servlet:2.3.12.Final")
-		api("io.undertow:undertow-websockets-jsr:2.3.12.Final")
+		api("io.undertow:undertow-core:2.3.10.Final")
+		api("io.undertow:undertow-servlet:2.3.10.Final")
+		api("io.undertow:undertow-websockets-jsr:2.3.10.Final")
 		api("io.vavr:vavr:0.10.4")
 		api("jakarta.activation:jakarta.activation-api:2.0.1")
 		api("jakarta.annotation:jakarta.annotation-api:2.0.0")
@@ -100,22 +99,23 @@ dependencies {
 		api("org.apache.derby:derby:10.16.1.1")
 		api("org.apache.derby:derbyclient:10.16.1.1")
 		api("org.apache.derby:derbytools:10.16.1.1")
-		api("org.apache.httpcomponents.client5:httpclient5:5.3.1")
-		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.2.4")
-		api("org.apache.poi:poi-ooxml:5.2.5")
-		api("org.apache.tomcat.embed:tomcat-embed-core:10.1.19")
-		api("org.apache.tomcat.embed:tomcat-embed-websocket:10.1.19")
-		api("org.apache.tomcat:tomcat-util:10.1.19")
-		api("org.apache.tomcat:tomcat-websocket:10.1.19")
-		api("org.aspectj:aspectjrt:1.9.21.1")
-		api("org.aspectj:aspectjtools:1.9.21.1")
-		api("org.aspectj:aspectjweaver:1.9.21.1")
+		api("org.apache.httpcomponents.client5:httpclient5:5.2.1")
+		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.2.3")
+		api("org.apache.poi:poi-ooxml:5.2.4")
+		api("org.apache.tomcat.embed:tomcat-embed-core:10.1.16")
+		api("org.apache.tomcat.embed:tomcat-embed-websocket:10.1.16")
+		api("org.apache.tomcat:tomcat-util:10.1.16")
+		api("org.apache.tomcat:tomcat-websocket:10.1.16")
+		api("org.aspectj:aspectjrt:1.9.20.1")
+		api("org.aspectj:aspectjtools:1.9.20.1")
+		api("org.aspectj:aspectjweaver:1.9.20.1")
+		api("org.assertj:assertj-core:3.24.2")
 		api("org.awaitility:awaitility:4.2.0")
 		api("org.bouncycastle:bcpkix-jdk18on:1.72")
 		api("org.codehaus.jettison:jettison:1.5.4")
 		api("org.crac:crac:1.4.0")
 		api("org.dom4j:dom4j:2.1.4")
-		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.3")
+		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.1")
 		api("org.eclipse.persistence:org.eclipse.persistence.jpa:3.0.4")
 		api("org.eclipse:yasson:2.0.4")
 		api("org.ehcache:ehcache:3.10.8")
@@ -130,8 +130,8 @@ dependencies {
 		api("org.hibernate:hibernate-validator:7.0.5.Final")
 		api("org.hsqldb:hsqldb:2.7.2")
 		api("org.javamoney:moneta:1.4.2")
-		api("org.jruby:jruby:9.4.6.0")
-		api("org.junit.support:testng-engine:1.0.5")
+		api("org.jruby:jruby:9.4.5.0")
+		api("org.junit.support:testng-engine:1.0.4")
 		api("org.mozilla:rhino:1.7.14")
 		api("org.ogce:xpp3:1.1.6")
 		api("org.python:jython-standalone:2.7.3")
@@ -139,8 +139,8 @@ dependencies {
 		api("org.seleniumhq.selenium:htmlunit-driver:2.70.0")
 		api("org.seleniumhq.selenium:selenium-java:3.141.59")
 		api("org.skyscreamer:jsonassert:1.5.1")
-		api("org.slf4j:slf4j-api:2.0.12")
-		api("org.testng:testng:7.9.0")
+		api("org.slf4j:slf4j-api:2.0.9")
+		api("org.testng:testng:7.8.0")
 		api("org.webjars:underscorejs:1.8.3")
 		api("org.webjars:webjars-locator-core:0.55")
 		api("org.xmlunit:xmlunit-assertj:2.9.1")
@@ -1,10 +1,10 @@
-version=6.1.5
+version=6.1.2

 org.gradle.caching=true
 org.gradle.jvmargs=-Xmx2048m
 org.gradle.parallel=true

-kotlinVersion=1.9.22
+kotlinVersion=1.9.21

 kotlin.jvm.target.validation.mode=ignore
 kotlin.stdlib.default.dependency=false
@@ -8,9 +8,8 @@ apply plugin: 'me.champeau.jmh'
 apply from: "$rootDir/gradle/publications.gradle"

 dependencies {
-	jmh 'org.openjdk.jmh:jmh-core:1.37'
-	jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.37'
-	jmh 'org.openjdk.jmh:jmh-generator-bytecode:1.37'
+	jmh 'org.openjdk.jmh:jmh-core:1.36'
+	jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.36'
 	jmh 'net.sf.jopt-simple:jopt-simple'
 }

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
@@ -43,11 +43,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute

-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.

 goto fail

@@ -57,11 +57,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe

 if exist "%JAVA_EXE%" goto execute

-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.

 goto fail

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -75,7 +75,7 @@ class AopNamespaceHandlerScopeIntegrationTests {
 	}

 	@Test
-	void testRequestScoping() {
+	void testRequestScoping() throws Exception {
 		MockHttpServletRequest oldRequest = new MockHttpServletRequest();
 		MockHttpServletRequest newRequest = new MockHttpServletRequest();

@@ -103,7 +103,7 @@ class AopNamespaceHandlerScopeIntegrationTests {
 	}

 	@Test
-	void testSessionScoping() {
+	void testSessionScoping() throws Exception {
 		MockHttpSession oldSession = new MockHttpSession();
 		MockHttpSession newSession = new MockHttpSession();

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@

 package org.springframework.aop.framework.autoproxy;

+import java.io.IOException;
 import java.lang.reflect.Method;
 import java.util.List;

@@ -60,12 +61,12 @@ class AdvisorAutoProxyCreatorIntegrationTests {
 	/**
 	 * Return a bean factory with attributes and EnterpriseServices configured.
 	 */
-	protected BeanFactory getBeanFactory() {
+	protected BeanFactory getBeanFactory() throws IOException {
 		return new ClassPathXmlApplicationContext(DEFAULT_CONTEXT, CLASS);
 	}

 	@Test
-	void testDefaultExclusionPrefix() {
+	void testDefaultExclusionPrefix() throws Exception {
 		DefaultAdvisorAutoProxyCreator aapc = (DefaultAdvisorAutoProxyCreator) getBeanFactory().getBean(ADVISOR_APC_BEAN_NAME);
 		assertThat(aapc.getAdvisorBeanNamePrefix()).isEqualTo((ADVISOR_APC_BEAN_NAME + DefaultAdvisorAutoProxyCreator.SEPARATOR));
 		assertThat(aapc.isUsePrefix()).isFalse();
@@ -75,21 +76,21 @@ class AdvisorAutoProxyCreatorIntegrationTests {
 	 * If no pointcuts match (no attrs) there should be proxying.
 	 */
 	@Test
-	void testNoProxy() {
+	void testNoProxy() throws Exception {
 		BeanFactory bf = getBeanFactory();
 		Object o = bf.getBean("noSetters");
 		assertThat(AopUtils.isAopProxy(o)).isFalse();
 	}

 	@Test
-	void testTxIsProxied() {
+	void testTxIsProxied() throws Exception {
 		BeanFactory bf = getBeanFactory();
 		ITestBean test = (ITestBean) bf.getBean("test");
 		assertThat(AopUtils.isAopProxy(test)).isTrue();
 	}

 	@Test
-	void testRegexpApplied() {
+	void testRegexpApplied() throws Exception {
 		BeanFactory bf = getBeanFactory();
 		ITestBean test = (ITestBean) bf.getBean("test");
 		MethodCounter counter = (MethodCounter) bf.getBean("countingAdvice");
@@ -99,7 +100,7 @@ class AdvisorAutoProxyCreatorIntegrationTests {
 	}

 	@Test
-	void testTransactionAttributeOnMethod() {
+	void testTransactionAttributeOnMethod() throws Exception {
 		BeanFactory bf = getBeanFactory();
 		ITestBean test = (ITestBean) bf.getBean("test");

@@ -165,7 +166,7 @@ class AdvisorAutoProxyCreatorIntegrationTests {
 	}

 	@Test
-	void testProgrammaticRollback() {
+	void testProgrammaticRollback() throws Exception {
 		BeanFactory bf = getBeanFactory();

 		Object bean = bf.getBean(TXMANAGER_BEAN_NAME);
@@ -249,7 +250,7 @@ class OrderedTxCheckAdvisor extends StaticMethodMatcherPointcutAdvisor implement
 	}

 	@Override
-	public void afterPropertiesSet() {
+	public void afterPropertiesSet() throws Exception {
 		setAdvice(new TxCountingBeforeAdvice());
 	}

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -46,7 +46,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 * @author Brian Clozel
 */
@EnabledIfRuntimeHintsAgent
-class RuntimeHintsAgentTests {
+public class RuntimeHintsAgentTests {

 	private static final ClassLoader classLoader = ClassLoader.getSystemClassLoader();

@@ -58,7 +58,7 @@ class RuntimeHintsAgentTests {


 	@BeforeAll
-	static void classSetup() throws NoSuchMethodException {
+	public static void classSetup() throws NoSuchMethodException {
 		defaultConstructor = String.class.getConstructor();
 		toStringMethod = String.class.getMethod("toString");
 		privateGreetMethod = PrivateClass.class.getDeclaredMethod("greet");
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -39,7 +39,7 @@ class ComponentBeanDefinitionParserTests {


 	@BeforeAll
-	void setUp() {
+	void setUp() throws Exception {
 		new XmlBeanDefinitionReader(bf).loadBeanDefinitions(
 			new ClassPathResource("component-config.xml", ComponentBeanDefinitionParserTests.class));
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -34,7 +34,7 @@ public class ComponentFactoryBean implements FactoryBean<Component> {
 	}

 	@Override
-	public Component getObject() {
+	public Component getObject() throws Exception {
 		if (this.children != null && this.children.size() > 0) {
 			for (Component child : children) {
 				this.parent.addComponent(child);
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -42,6 +42,7 @@ import static org.assertj.core.api.Assertions.assertThatException;
 * @author Chris Beams
 * @since 3.1
 */
+@SuppressWarnings("resource")
 class EnableCachingIntegrationTests {

 	@Test
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -87,6 +87,7 @@ import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Con
 * @author Sam Brannen
 * @see org.springframework.context.support.EnvironmentIntegrationTests
 */
+@SuppressWarnings("resource")
 public class EnvironmentSystemIntegrationTests {

 	private final ConfigurableEnvironment prodEnv = new StandardEnvironment();
@@ -617,7 +618,7 @@ public class EnvironmentSystemIntegrationTests {
 	@Import({DevConfig.class, ProdConfig.class})
 	static class Config {
 		@Bean
-		EnvironmentAwareBean envAwareBean() {
+		public EnvironmentAwareBean envAwareBean() {
 			return new EnvironmentAwareBean();
 		}
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -27,7 +27,6 @@ import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.expression.TypeConverter;
-import org.springframework.util.ClassUtils;

 /**
 * Copied from Spring Integration for purposes of reproducing
@@ -60,9 +59,11 @@ class BeanFactoryTypeConverter implements TypeConverter, BeanFactoryAware {

 	@Override
 	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
-		if (beanFactory instanceof ConfigurableBeanFactory cbf &&
-				cbf.getTypeConverter() instanceof SimpleTypeConverter simpleTypeConverter) {
-			this.delegate = simpleTypeConverter;
+		if (beanFactory instanceof ConfigurableBeanFactory) {
+			Object typeConverter = ((ConfigurableBeanFactory) beanFactory).getTypeConverter();
+			if (typeConverter instanceof SimpleTypeConverter) {
+				delegate = (SimpleTypeConverter) typeConverter;
+			}
 		}
 	}

@@ -85,6 +86,7 @@ class BeanFactoryTypeConverter implements TypeConverter, BeanFactoryAware {
 		if (conversionService.canConvert(sourceTypeDescriptor, targetTypeDescriptor)) {
 			return true;
 		}
+		// TODO: what does this mean? This method is not used in SpEL so probably ignorable?
 		Class<?> sourceType = sourceTypeDescriptor.getObjectType();
 		Class<?> targetType = targetTypeDescriptor.getObjectType();
 		return canConvert(sourceType, targetType);
@@ -92,7 +94,7 @@ class BeanFactoryTypeConverter implements TypeConverter, BeanFactoryAware {

 	@Override
 	public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType) {
-		if (ClassUtils.isVoidType(targetType.getType())) {
+		if (targetType.getType() == Void.class || targetType.getType() == Void.TYPE) {
 			return null;
 		}
 		if (conversionService.canConvert(sourceType, targetType)) {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -51,6 +51,7 @@ import static org.springframework.core.testfixture.TestGroup.LONG_RUNNING;
 * @author Juergen Hoeller
 * @since 3.1
 */
+@SuppressWarnings("resource")
@EnabledForTestGroups(LONG_RUNNING)
 class ScheduledAndTransactionalAnnotationIntegrationTests {

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -54,6 +54,7 @@ import static org.assertj.core.api.Assertions.assertThatException;
 * @author Sam Brannen
 * @since 3.1
 */
+@SuppressWarnings("resource")
 class EnableTransactionManagementIntegrationTests {

 	@Test
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -27,13 +27,14 @@ import static org.assertj.core.api.Assertions.assertThat;
 /**
 * Tests proving that regardless the proxy strategy used (JDK interface-based vs. CGLIB
 * subclass-based), discovery of advice-oriented annotations is consistent.
- * <p>
+ *
 * For example, Spring's @Transactional may be declared at the interface or class level,
 * and whether interface or subclass proxies are used, the @Transactional annotation must
 * be discovered in a consistent fashion.
 *
 * @author Chris Beams
 */
+@SuppressWarnings("resource")
 class ProxyAnnotationDiscoveryTests {

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

 import kotlinx.coroutines.delay
@@ -110,12 +94,12 @@ class AspectJAutoProxyInterceptorKotlinIntegrationTests(
    open class Echo {

        open fun echo(value: String): String {
-            return value
+            return value;
        }

        open suspend fun suspendingEcho(value: String): String {
            delay(1)
-            return value
+            return value;
        }

    }
@@ -1,6 +1,6 @@
 plugins {
-	id "com.gradle.enterprise" version "3.16.2"
-	id "io.spring.ge.conventions" version "0.0.15"
+	id "com.gradle.enterprise" version "3.14"
+	id "io.spring.ge.conventions" version "0.0.13"
 	id "org.gradle.toolchains.foojay-resolver-convention" version "0.7.0"
 }

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -334,15 +334,13 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		Object targetObject = null;
 		Object thisObject = null;
 		try {
-			MethodInvocation curr = ExposeInvocationInterceptor.currentInvocation();
-			if (curr.getMethod() == method) {
-				targetObject = curr.getThis();
-				if (!(curr instanceof ProxyMethodInvocation currPmi)) {
-					throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + curr);
-				}
-				pmi = currPmi;
-				thisObject = pmi.getProxy();
+			MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
+			targetObject = mi.getThis();
+			if (!(mi instanceof ProxyMethodInvocation _pmi)) {
+				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
 			}
+			pmi = _pmi;
+			thisObject = pmi.getProxy();
 		}
 		catch (IllegalStateException ex) {
 			// No current invocation...
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -293,7 +293,7 @@ final class InstantiationModelAwarePointcutAdvisorImpl
 		@Override
 		public boolean matches(Method method, Class<?> targetClass, Object... args) {
 			// This can match only on declared pointcut.
-			return (isAspectMaterialized() && this.declaredPointcut.matches(method, targetClass, args));
+			return (isAspectMaterialized() && this.declaredPointcut.matches(method, targetClass));
 		}

 		private boolean isAspectMaterialized() {
@@ -201,8 +201,9 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 			List<BeanReference> beanReferences = new ArrayList<>();

 			List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, DECLARE_PARENTS);
-			for (Element declareParent : declareParents) {
-				beanDefinitions.add(parseDeclareParents(declareParent, parserContext));
+			for (int i = METHOD_INDEX; i < declareParents.size(); i++) {
+				Element declareParentsElement = declareParents.get(i);
+				beanDefinitions.add(parseDeclareParents(declareParentsElement, parserContext));
 			}

 			// We have to parse "advice" and all the advice kinds in one loop, to get the
@@ -404,14 +405,24 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	 */
 	private Class<?> getAdviceClass(Element adviceElement, ParserContext parserContext) {
 		String elementName = parserContext.getDelegate().getLocalName(adviceElement);
-		return switch (elementName) {
-			case BEFORE -> AspectJMethodBeforeAdvice.class;
-			case AFTER -> AspectJAfterAdvice.class;
-			case AFTER_RETURNING_ELEMENT -> AspectJAfterReturningAdvice.class;
-			case AFTER_THROWING_ELEMENT -> AspectJAfterThrowingAdvice.class;
-			case AROUND -> AspectJAroundAdvice.class;
-			default -> throw new IllegalArgumentException("Unknown advice kind [" + elementName + "].");
-		};
+		if (BEFORE.equals(elementName)) {
+			return AspectJMethodBeforeAdvice.class;
+		}
+		else if (AFTER.equals(elementName)) {
+			return AspectJAfterAdvice.class;
+		}
+		else if (AFTER_RETURNING_ELEMENT.equals(elementName)) {
+			return AspectJAfterReturningAdvice.class;
+		}
+		else if (AFTER_THROWING_ELEMENT.equals(elementName)) {
+			return AspectJAfterThrowingAdvice.class;
+		}
+		else if (AROUND.equals(elementName)) {
+			return AspectJAroundAdvice.class;
+		}
+		else {
+			throw new IllegalArgumentException("Unknown advice kind [" + elementName + "].");
+		}
 	}

 	/**
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2021 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -42,8 +42,10 @@ class ScopedProxyBeanDefinitionDecorator implements BeanDefinitionDecorator {
 	@Override
 	public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
 		boolean proxyTargetClass = true;
-		if (node instanceof Element ele && ele.hasAttribute(PROXY_TARGET_CLASS)) {
-			proxyTargetClass = Boolean.parseBoolean(ele.getAttribute(PROXY_TARGET_CLASS));
+		if (node instanceof Element ele) {
+			if (ele.hasAttribute(PROXY_TARGET_CLASS)) {
+				proxyTargetClass = Boolean.parseBoolean(ele.getAttribute(PROXY_TARGET_CLASS));
+			}
 		}

 		// Register the original bean definition as it will be referenced by the scoped proxy
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@ import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -84,7 +85,10 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	private boolean preFiltered = false;

 	/** The AdvisorChainFactory to use. */
-	private AdvisorChainFactory advisorChainFactory = DefaultAdvisorChainFactory.INSTANCE;
+	private AdvisorChainFactory advisorChainFactory;
+
+	/** Cache with Method as key and advisor chain List as value. */
+	private transient Map<MethodCacheKey, List<Object>> methodCache;

 	/**
 	 * Interfaces to be implemented by the proxy. Held in List to keep the order
@@ -98,36 +102,15 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 */
 	private List<Advisor> advisors = new ArrayList<>();

-	/**
-	 * List of minimal {@link AdvisorKeyEntry} instances,
-	 * to be assigned to the {@link #advisors} field on reduction.
-	 * @since 6.0.10
-	 * @see #reduceToAdvisorKey
-	 */
 	private List<Advisor> advisorKey = this.advisors;

-	/** Cache with Method as key and advisor chain List as value. */
-	@Nullable
-	private transient Map<MethodCacheKey, List<Object>> methodCache;
-
-	/** Cache with shared interceptors which are not method-specific. */
-	@Nullable
-	private transient volatile List<Object> cachedInterceptors;
-
-	/**
-	 * Optional field for {@link AopProxy} implementations to store metadata in.
-	 * Used by {@link JdkDynamicAopProxy}.
-	 * @since 6.1.3
-	 * @see JdkDynamicAopProxy#JdkDynamicAopProxy(AdvisedSupport)
-	 */
-	@Nullable
-	transient volatile Object proxyMetadataCache;
-

 	/**
 	 * No-arg constructor for use as a JavaBean.
 	 */
 	public AdvisedSupport() {
+		this.advisorChainFactory = DefaultAdvisorChainFactory.INSTANCE;
+		this.methodCache = new ConcurrentHashMap<>(32);
 	}

 	/**
@@ -135,9 +118,19 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * @param interfaces the proxied interfaces
 	 */
 	public AdvisedSupport(Class<?>... interfaces) {
+		this();
 		setInterfaces(interfaces);
 	}

+	/**
+	 * Internal constructor for {@link #getConfigurationOnlyCopy()}.
+	 * @since 6.0.10
+	 */
+	private AdvisedSupport(AdvisorChainFactory advisorChainFactory, Map<MethodCacheKey, List<Object>> methodCache) {
+		this.advisorChainFactory = advisorChainFactory;
+		this.methodCache = methodCache;
+	}
+

 	/**
 	 * Set the given object as target.
@@ -489,18 +482,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * @return a List of MethodInterceptors (may also include InterceptorAndDynamicMethodMatchers)
 	 */
 	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
-		if (this.methodCache == null) {
-			// Shared cache since there are no method-specific advisors (see below).
-			List<Object> cachedInterceptors = this.cachedInterceptors;
-			if (cachedInterceptors == null) {
-				cachedInterceptors = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
-						this, method, targetClass);
-				this.cachedInterceptors = cachedInterceptors;
-			}
-			return cachedInterceptors;
-		}
-
-		// Method-specific cache for method-specific pointcuts
 		return this.methodCache.computeIfAbsent(new MethodCacheKey(method), k ->
 				this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this, method, targetClass));
 	}
@@ -509,18 +490,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * Invoked when advice has changed.
 	 */
 	protected void adviceChanged() {
-		this.methodCache = null;
-		this.cachedInterceptors = null;
-		this.proxyMetadataCache = null;
-
-		// Initialize method cache if necessary; otherwise,
-		// cachedInterceptors is going to be shared (see above).
-		for (Advisor advisor : this.advisors) {
-			if (advisor instanceof PointcutAdvisor) {
-				this.methodCache = new ConcurrentHashMap<>();
-				break;
-			}
-		}
+		this.methodCache.clear();
 	}

 	/**
@@ -559,28 +529,21 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * replacing the {@link TargetSource}.
 	 */
 	AdvisedSupport getConfigurationOnlyCopy() {
-		AdvisedSupport copy = new AdvisedSupport();
+		AdvisedSupport copy = new AdvisedSupport(this.advisorChainFactory, this.methodCache);
 		copy.copyFrom(this);
 		copy.targetSource = EmptyTargetSource.forClass(getTargetClass(), getTargetSource().isStatic());
-		copy.preFiltered = this.preFiltered;
-		copy.advisorChainFactory = this.advisorChainFactory;
 		copy.interfaces = new ArrayList<>(this.interfaces);
 		copy.advisors = new ArrayList<>(this.advisors);
 		copy.advisorKey = new ArrayList<>(this.advisors.size());
 		for (Advisor advisor : this.advisors) {
 			copy.advisorKey.add(new AdvisorKeyEntry(advisor));
 		}
-		copy.methodCache = this.methodCache;
-		copy.cachedInterceptors = this.cachedInterceptors;
-		copy.proxyMetadataCache = this.proxyMetadataCache;
 		return copy;
 	}

 	void reduceToAdvisorKey() {
 		this.advisors = this.advisorKey;
-		this.methodCache = null;
-		this.cachedInterceptors = null;
-		this.proxyMetadataCache = null;
+		this.methodCache = Collections.emptyMap();
 	}

 	Object getAdvisorKey() {
@@ -588,6 +551,18 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}


+	//---------------------------------------------------------------------
+	// Serialization support
+	//---------------------------------------------------------------------
+
+	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+		// Rely on default serialization; just initialize state after deserialization.
+		ois.defaultReadObject();
+
+		// Initialize transient fields.
+		this.methodCache = new ConcurrentHashMap<>(32);
+	}
+
 	@Override
 	public String toProxyConfigString() {
 		return toString();
@@ -609,19 +584,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}


-	//---------------------------------------------------------------------
-	// Serialization support
-	//---------------------------------------------------------------------
-
-	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
-		// Rely on default serialization; just initialize state after deserialization.
-		ois.defaultReadObject();
-
-		// Initialize method cache if necessary.
-		adviceChanged();
-	}
-
-
 	/**
 	 * Simple wrapper class around a Method. Used as the key when
 	 * caching methods, for efficient equals and hashCode comparisons.
@@ -671,7 +633,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * @see #getConfigurationOnlyCopy()
 	 * @see #getAdvisorKey()
 	 */
-	private static final class AdvisorKeyEntry implements Advisor {
+	private static class AdvisorKeyEntry implements Advisor {

 		private final Class<?> adviceType;

@@ -681,6 +643,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		@Nullable
 		private final String methodMatcherKey;

+
 		public AdvisorKeyEntry(Advisor advisor) {
 			this.adviceType = advisor.getAdvice().getClass();
 			if (advisor instanceof PointcutAdvisor pointcutAdvisor) {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -417,7 +417,7 @@ class CglibAopProxy implements AopProxy, Serializable {
 			returnValue = proxy;
 		}
 		Class<?> returnType = method.getReturnType();
-		if (returnValue == null && returnType != void.class && returnType.isPrimitive()) {
+		if (returnValue == null && returnType != Void.TYPE && returnType.isPrimitive()) {
 			throw new AopInvocationException(
 					"Null return value from advice does not match primitive return type for: " + method);
 		}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -32,13 +32,8 @@ import org.springframework.lang.Nullable;
 */
 abstract class CoroutinesUtils {

-	static Object asFlow(@Nullable Object publisher) {
-		if (publisher instanceof Publisher<?> rsPublisher) {
-			return ReactiveFlowKt.asFlow(rsPublisher);
-		}
-		else {
-			throw new IllegalArgumentException("Not a Reactive Streams Publisher: " + publisher);
-		}
+	static Object asFlow(Object publisher) {
+		return ReactiveFlowKt.asFlow((Publisher<?>) publisher);
 	}

 	@Nullable
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -16,8 +16,6 @@

 package org.springframework.aop.framework;

-import java.io.IOException;
-import java.io.ObjectInputStream;
 import java.io.Serializable;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
@@ -73,16 +71,34 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	private static final long serialVersionUID = 5531744639992436476L;


-	private static final String COROUTINES_FLOW_CLASS_NAME = "kotlinx.coroutines.flow.Flow";
+	/*
+	 * NOTE: We could avoid the code duplication between this class and the CGLIB
+	 * proxies by refactoring "invoke" into a template method. However, this approach
+	 * adds at least 10% performance overhead versus a copy-paste solution, so we sacrifice
+	 * elegance for performance (we have a good test suite to ensure that the different
+	 * proxies behave the same :-)).
+	 * This way, we can also more easily take advantage of minor optimizations in each class.
+	 */

 	/** We use a static Log to avoid serialization issues. */
 	private static final Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);

+	private static final String COROUTINES_FLOW_CLASS_NAME = "kotlinx.coroutines.flow.Flow";
+
 	/** Config used to configure this proxy. */
 	private final AdvisedSupport advised;

-	/** Cached in {@link AdvisedSupport#proxyMetadataCache}. */
-	private transient ProxiedInterfacesCache cache;
+	private final Class<?>[] proxiedInterfaces;
+
+	/**
+	 * Is the {@link #equals} method defined on the proxied interfaces?
+	 */
+	private boolean equalsDefined;
+
+	/**
+	 * Is the {@link #hashCode} method defined on the proxied interfaces?
+	 */
+	private boolean hashCodeDefined;


 	/**
@@ -94,17 +110,8 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
 		Assert.notNull(config, "AdvisedSupport must not be null");
 		this.advised = config;
-
-		// Initialize ProxiedInterfacesCache if not cached already
-		ProxiedInterfacesCache cache;
-		if (config.proxyMetadataCache instanceof ProxiedInterfacesCache proxiedInterfacesCache) {
-			cache = proxiedInterfacesCache;
-		}
-		else {
-			cache = new ProxiedInterfacesCache(config);
-			config.proxyMetadataCache = cache;
-		}
-		this.cache = cache;
+		this.proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
+		findDefinedEqualsAndHashCodeMethods(this.proxiedInterfaces);
 	}


@@ -118,13 +125,13 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 		if (logger.isTraceEnabled()) {
 			logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
 		}
-		return Proxy.newProxyInstance(determineClassLoader(classLoader), this.cache.proxiedInterfaces, this);
+		return Proxy.newProxyInstance(determineClassLoader(classLoader), this.proxiedInterfaces, this);
 	}

 	@SuppressWarnings("deprecation")
 	@Override
 	public Class<?> getProxyClass(@Nullable ClassLoader classLoader) {
-		return Proxy.getProxyClass(determineClassLoader(classLoader), this.cache.proxiedInterfaces);
+		return Proxy.getProxyClass(determineClassLoader(classLoader), this.proxiedInterfaces);
 	}

 	/**
@@ -153,6 +160,28 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 		return classLoader;
 	}

+	/**
+	 * Finds any {@link #equals} or {@link #hashCode} method that may be defined
+	 * on the supplied set of interfaces.
+	 * @param proxiedInterfaces the interfaces to introspect
+	 */
+	private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) {
+		for (Class<?> proxiedInterface : proxiedInterfaces) {
+			Method[] methods = proxiedInterface.getDeclaredMethods();
+			for (Method method : methods) {
+				if (AopUtils.isEqualsMethod(method)) {
+					this.equalsDefined = true;
+				}
+				if (AopUtils.isHashCodeMethod(method)) {
+					this.hashCodeDefined = true;
+				}
+				if (this.equalsDefined && this.hashCodeDefined) {
+					return;
+				}
+			}
+		}
+	}
+

 	/**
 	 * Implementation of {@code InvocationHandler.invoke}.
@@ -169,11 +198,11 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 		Object target = null;

 		try {
-			if (!this.cache.equalsDefined && AopUtils.isEqualsMethod(method)) {
+			if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
 				// The target does not implement the equals(Object) method itself.
 				return equals(args[0]);
 			}
-			else if (!this.cache.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
+			else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
 				// The target does not implement the hashCode() method itself.
 				return hashCode();
 			}
@@ -230,7 +259,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 				// a reference to itself in another returned object.
 				retVal = proxy;
 			}
-			else if (retVal == null && returnType != void.class && returnType.isPrimitive()) {
+			else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
 				throw new AopInvocationException(
 						"Null return value from advice does not match primitive return type for: " + method);
 			}
@@ -295,63 +324,4 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 		return JdkDynamicAopProxy.class.hashCode() * 13 + this.advised.getTargetSource().hashCode();
 	}

-
-	//---------------------------------------------------------------------
-	// Serialization support
-	//---------------------------------------------------------------------
-
-	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
-		// Rely on default serialization; just initialize state after deserialization.
-		ois.defaultReadObject();
-
-		// Initialize transient fields.
-		this.cache = new ProxiedInterfacesCache(this.advised);
-	}
-
-
-	/**
-	 * Holder for the complete proxied interfaces and derived metadata,
-	 * to be cached in {@link AdvisedSupport#proxyMetadataCache}.
-	 * @since 6.1.3
-	 */
-	private static final class ProxiedInterfacesCache {
-
-		final Class<?>[] proxiedInterfaces;
-
-		final boolean equalsDefined;
-
-		final boolean hashCodeDefined;
-
-		ProxiedInterfacesCache(AdvisedSupport config) {
-			this.proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(config, true);
-
-			// Find any {@link #equals} or {@link #hashCode} method that may be defined
-			// on the supplied set of interfaces.
-			boolean equalsDefined = false;
-			boolean hashCodeDefined = false;
-			for (Class<?> proxiedInterface : this.proxiedInterfaces) {
-				Method[] methods = proxiedInterface.getDeclaredMethods();
-				for (Method method : methods) {
-					if (AopUtils.isEqualsMethod(method)) {
-						equalsDefined = true;
-						if (hashCodeDefined) {
-							break;
-						}
-					}
-					if (AopUtils.isHashCodeMethod(method)) {
-						hashCodeDefined = true;
-						if (equalsDefined) {
-							break;
-						}
-					}
-				}
-				if (equalsDefined && hashCodeDefined) {
-					break;
-				}
-			}
-			this.equalsDefined = equalsDefined;
-			this.hashCodeDefined = hashCodeDefined;
-		}
-	}
-
 }
@@ -58,7 +58,6 @@ import org.springframework.util.function.SingletonSupplier;
 * @author Juergen Hoeller
 * @author Stephane Nicoll
 * @author He Bo
- * @author Sebastien Deleuze
 * @since 3.1.2
 */
 public abstract class AsyncExecutionAspectSupport implements BeanFactoryAware {
@@ -293,7 +292,7 @@ public abstract class AsyncExecutionAspectSupport implements BeanFactoryAware {
 		else if (Future.class.isAssignableFrom(returnType)) {
 			return executor.submit(task);
 		}
-		else if (void.class == returnType || "kotlin.Unit".equals(returnType.getName())) {
+		else if (void.class == returnType) {
 			executor.submit(task);
 			return null;
 		}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -32,6 +32,7 @@ import org.springframework.core.Ordered;
 import org.springframework.core.task.AsyncTaskExecutor;
 import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.springframework.lang.Nullable;
+import org.springframework.util.ClassUtils;

 /**
 * AOP Alliance {@code MethodInterceptor} that processes method invocations
@@ -100,9 +101,10 @@ public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport imple
 	@Nullable
 	public Object invoke(final MethodInvocation invocation) throws Throwable {
 		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
-		final Method userMethod = BridgeMethodResolver.getMostSpecificMethod(invocation.getMethod(), targetClass);
+		Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);
+		final Method userDeclaredMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);

-		AsyncTaskExecutor executor = determineAsyncExecutor(userMethod);
+		AsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod);
 		if (executor == null) {
 			throw new IllegalStateException(
 					"No executor specified and no default executor set on AsyncExecutionInterceptor either");
@@ -116,10 +118,10 @@ public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport imple
 				}
 			}
 			catch (ExecutionException ex) {
-				handleError(ex.getCause(), userMethod, invocation.getArguments());
+				handleError(ex.getCause(), userDeclaredMethod, invocation.getArguments());
 			}
 			catch (Throwable ex) {
-				handleError(ex, userMethod, invocation.getArguments());
+				handleError(ex, userDeclaredMethod, invocation.getArguments());
 			}
 			return null;
 		};
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -194,16 +194,17 @@ public abstract class AopUtils {
 	 * this method resolves bridge methods in order to retrieve attributes from
 	 * the <i>original</i> method definition.
 	 * @param method the method to be invoked, which may come from an interface
-	 * @param targetClass the target class for the current invocation
-	 * (can be {@code null} or may not even implement the method)
+	 * @param targetClass the target class for the current invocation.
+	 * May be {@code null} or may not even implement the method.
 	 * @return the specific target method, or the original method if the
-	 * {@code targetClass} does not implement it
+	 * {@code targetClass} doesn't implement it or is {@code null}
 	 * @see org.springframework.util.ClassUtils#getMostSpecificMethod
-	 * @see org.springframework.core.BridgeMethodResolver#getMostSpecificMethod
 	 */
 	public static Method getMostSpecificMethod(Method method, @Nullable Class<?> targetClass) {
 		Class<?> specificTargetClass = (targetClass != null ? ClassUtils.getUserClass(targetClass) : null);
-		return BridgeMethodResolver.getMostSpecificMethod(method, specificTargetClass);
+		Method resolvedMethod = ClassUtils.getMostSpecificMethod(method, specificTargetClass);
+		// If we are dealing with method with generic parameters, find the original method.
+		return BridgeMethodResolver.findBridgedMethod(resolvedMethod);
 	}

 	/**
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -52,7 +52,7 @@ public class ControlFlowPointcut implements Pointcut, ClassFilter, MethodMatcher

 	/**
 	 * The class against which to match.
-	 * @since 6.1
+	 * <p>Available for use in subclasses since 6.1.
 	 */
 	protected final Class<?> clazz;

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -101,7 +101,7 @@ public abstract class Pointcuts {
 		public boolean matches(Method method, Class<?> targetClass) {
 			return (method.getName().startsWith("set") &&
 					method.getParameterCount() == 1 &&
-					method.getReturnType() == void.class);
+					method.getReturnType() == Void.TYPE);
 		}

 		private Object readResolve() {
@@ -127,7 +127,7 @@ public abstract class Pointcuts {
 		public boolean matches(Method method, Class<?> targetClass) {
 			return (method.getName().startsWith("get") &&
 					method.getParameterCount() == 0 &&
-					method.getReturnType() != void.class);
+					method.getReturnType() != Void.TYPE);
 		}

 		private Object readResolve() {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -29,7 +29,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;

 /**
- * Tests for {@link AspectJAdviceParameterNameDiscoverer}.
+ * Unit tests for {@link AspectJAdviceParameterNameDiscoverer}.
 *
 * @author Adrian Colyer
 * @author Chris Beams
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ import java.util.Map;

 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;
+import org.aspectj.weaver.tools.PointcutExpression;
 import org.aspectj.weaver.tools.PointcutPrimitive;
 import org.aspectj.weaver.tools.UnsupportedPointcutPrimitiveException;
 import org.junit.jupiter.api.BeforeEach;
@@ -51,7 +52,9 @@ import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 * @author Chris Beams
 * @author Yanming Zhou
 */
-class AspectJExpressionPointcutTests {
+public class AspectJExpressionPointcutTests {
+
+	public static final String MATCH_ALL_METHODS = "execution(* *(..))";

 	private Method getAge;

@@ -63,7 +66,7 @@ class AspectJExpressionPointcutTests {


 	@BeforeEach
-	public void setup() throws NoSuchMethodException {
+	public void setUp() throws NoSuchMethodException {
 		getAge = TestBean.class.getMethod("getAge");
 		setAge = TestBean.class.getMethod("setAge", int.class);
 		setSomeNumber = TestBean.class.getMethod("setSomeNumber", Number.class);
@@ -76,7 +79,7 @@ class AspectJExpressionPointcutTests {


 	@Test
-	void testMatchExplicit() {
+	public void testMatchExplicit() {
 		String expression = "execution(int org.springframework.beans.testfixture.beans.TestBean.getAge())";

 		Pointcut pointcut = getPointcut(expression);
@@ -94,7 +97,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testMatchWithTypePattern() {
+	public void testMatchWithTypePattern() throws Exception {
 		String expression = "execution(* *..TestBean.*Age(..))";

 		Pointcut pointcut = getPointcut(expression);
@@ -113,12 +116,12 @@ class AspectJExpressionPointcutTests {


 	@Test
-	void testThis() throws SecurityException, NoSuchMethodException{
+	public void testThis() throws SecurityException, NoSuchMethodException{
 		testThisOrTarget("this");
 	}

 	@Test
-	void testTarget() throws SecurityException, NoSuchMethodException {
+	public void testTarget() throws SecurityException, NoSuchMethodException {
 		testThisOrTarget("target");
 	}

@@ -142,12 +145,12 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testWithinRootPackage() throws SecurityException, NoSuchMethodException {
+	public void testWithinRootPackage() throws SecurityException, NoSuchMethodException {
 		testWithinPackage(false);
 	}

 	@Test
-	void testWithinRootAndSubpackages() throws SecurityException, NoSuchMethodException {
+	public void testWithinRootAndSubpackages() throws SecurityException, NoSuchMethodException {
 		testWithinPackage(true);
 	}

@@ -171,32 +174,32 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testFriendlyErrorOnNoLocationClassMatching() {
+	public void testFriendlyErrorOnNoLocationClassMatching() {
 		AspectJExpressionPointcut pc = new AspectJExpressionPointcut();
-		assertThatIllegalStateException()
-				.isThrownBy(() -> pc.matches(ITestBean.class))
-				.withMessageContaining("expression");
+		assertThatIllegalStateException().isThrownBy(() ->
+				pc.matches(ITestBean.class))
+			.withMessageContaining("expression");
 	}

 	@Test
-	void testFriendlyErrorOnNoLocation2ArgMatching() {
+	public void testFriendlyErrorOnNoLocation2ArgMatching() {
 		AspectJExpressionPointcut pc = new AspectJExpressionPointcut();
-		assertThatIllegalStateException()
-				.isThrownBy(() -> pc.matches(getAge, ITestBean.class))
-				.withMessageContaining("expression");
+		assertThatIllegalStateException().isThrownBy(() ->
+				pc.matches(getAge, ITestBean.class))
+			.withMessageContaining("expression");
 	}

 	@Test
-	void testFriendlyErrorOnNoLocation3ArgMatching() {
+	public void testFriendlyErrorOnNoLocation3ArgMatching() {
 		AspectJExpressionPointcut pc = new AspectJExpressionPointcut();
-		assertThatIllegalStateException()
-				.isThrownBy(() -> pc.matches(getAge, ITestBean.class, (Object[]) null))
-				.withMessageContaining("expression");
+		assertThatIllegalStateException().isThrownBy(() ->
+				pc.matches(getAge, ITestBean.class, (Object[]) null))
+			.withMessageContaining("expression");
 	}


 	@Test
-	void testMatchWithArgs() throws Exception {
+	public void testMatchWithArgs() throws Exception {
 		String expression = "execution(void org.springframework.beans.testfixture.beans.TestBean.setSomeNumber(Number)) && args(Double)";

 		Pointcut pointcut = getPointcut(expression);
@@ -208,16 +211,14 @@ class AspectJExpressionPointcutTests {
 		// not currently testable in a reliable fashion
 		//assertDoesNotMatchStringClass(classFilter);

-		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, 12D))
-				.as("Should match with setSomeNumber with Double input").isTrue();
-		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, 11))
-				.as("Should not match setSomeNumber with Integer input").isFalse();
+		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, 12D)).as("Should match with setSomeNumber with Double input").isTrue();
+		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, 11)).as("Should not match setSomeNumber with Integer input").isFalse();
 		assertThat(methodMatcher.matches(getAge, TestBean.class)).as("Should not match getAge").isFalse();
 		assertThat(methodMatcher.isRuntime()).as("Should be a runtime match").isTrue();
 	}

 	@Test
-	void testSimpleAdvice() {
+	public void testSimpleAdvice() {
 		String expression = "execution(int org.springframework.beans.testfixture.beans.TestBean.getAge())";
 		CallCountingInterceptor interceptor = new CallCountingInterceptor();
 		TestBean testBean = getAdvisedProxy(expression, interceptor);
@@ -230,7 +231,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testDynamicMatchingProxy() {
+	public void testDynamicMatchingProxy() {
 		String expression = "execution(void org.springframework.beans.testfixture.beans.TestBean.setSomeNumber(Number)) && args(Double)";
 		CallCountingInterceptor interceptor = new CallCountingInterceptor();
 		TestBean testBean = getAdvisedProxy(expression, interceptor);
@@ -244,15 +245,16 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testInvalidExpression() {
+	public void testInvalidExpression() {
 		String expression = "execution(void org.springframework.beans.testfixture.beans.TestBean.setSomeNumber(Number) && args(Double)";
-		assertThatIllegalArgumentException().isThrownBy(getPointcut(expression)::getClassFilter);  // call to getClassFilter forces resolution
+		assertThatIllegalArgumentException().isThrownBy(
+				getPointcut(expression)::getClassFilter);  // call to getClassFilter forces resolution
 	}

 	private TestBean getAdvisedProxy(String pointcutExpression, CallCountingInterceptor interceptor) {
 		TestBean target = new TestBean();

-		AspectJExpressionPointcut pointcut = getPointcut(pointcutExpression);
+		Pointcut pointcut = getPointcut(pointcutExpression);

 		DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
 		advisor.setAdvice(interceptor);
@@ -274,35 +276,44 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testWithUnsupportedPointcutPrimitive() {
+	public void testWithUnsupportedPointcutPrimitive() {
 		String expression = "call(int org.springframework.beans.testfixture.beans.TestBean.getAge())";
-		assertThatExceptionOfType(UnsupportedPointcutPrimitiveException.class)
-				.isThrownBy(() -> getPointcut(expression).getClassFilter()) // call to getClassFilter forces resolution...
-				.satisfies(ex -> assertThat(ex.getUnsupportedPrimitive()).isEqualTo(PointcutPrimitive.CALL));
+		assertThatExceptionOfType(UnsupportedPointcutPrimitiveException.class).isThrownBy(() ->
+				getPointcut(expression).getClassFilter()) // call to getClassFilter forces resolution...
+			.satisfies(ex -> assertThat(ex.getUnsupportedPrimitive()).isEqualTo(PointcutPrimitive.CALL));
 	}

 	@Test
-	void testAndSubstitution() {
-		AspectJExpressionPointcut pc = getPointcut("execution(* *(..)) and args(String)");
-		String expr = pc.getPointcutExpression().getPointcutExpression();
-		assertThat(expr).isEqualTo("execution(* *(..)) && args(String)");
+	public void testAndSubstitution() {
+		Pointcut pc = getPointcut("execution(* *(..)) and args(String)");
+		PointcutExpression expr = ((AspectJExpressionPointcut) pc).getPointcutExpression();
+		assertThat(expr.getPointcutExpression()).isEqualTo("execution(* *(..)) && args(String)");
 	}

 	@Test
-	void testMultipleAndSubstitutions() {
-		AspectJExpressionPointcut pc = getPointcut("execution(* *(..)) and args(String) and this(Object)");
-		String expr = pc.getPointcutExpression().getPointcutExpression();
-		assertThat(expr).isEqualTo("execution(* *(..)) && args(String) && this(Object)");
+	public void testMultipleAndSubstitutions() {
+		Pointcut pc = getPointcut("execution(* *(..)) and args(String) and this(Object)");
+		PointcutExpression expr = ((AspectJExpressionPointcut) pc).getPointcutExpression();
+		assertThat(expr.getPointcutExpression()).isEqualTo("execution(* *(..)) && args(String) && this(Object)");
 	}

-	private AspectJExpressionPointcut getPointcut(String expression) {
+	private Pointcut getPointcut(String expression) {
 		AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
 		pointcut.setExpression(expression);
 		return pointcut;
 	}

+
+	public static class OtherIOther implements IOther {
+
+		@Override
+		public void absquatulate() {
+			// Empty
+		}
+	}
+
 	@Test
-	void testMatchGenericArgument() {
+	public void testMatchGenericArgument() {
 		String expression = "execution(* set*(java.util.List<org.springframework.beans.testfixture.beans.TestBean>) )";
 		AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
 		ajexp.setExpression(expression);
@@ -321,7 +332,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testMatchVarargs() throws Exception {
+	public void testMatchVarargs() throws Exception {

 		@SuppressWarnings("unused")
 		class MyTemplate {
@@ -347,19 +358,19 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testMatchAnnotationOnClassWithAtWithin() throws Exception {
+	public void testMatchAnnotationOnClassWithAtWithin() throws Exception {
 		String expression = "@within(test.annotation.transaction.Tx)";
 		testMatchAnnotationOnClass(expression);
 	}

 	@Test
-	void testMatchAnnotationOnClassWithoutBinding() throws Exception {
+	public void testMatchAnnotationOnClassWithoutBinding() throws Exception {
 		String expression = "within(@test.annotation.transaction.Tx *)";
 		testMatchAnnotationOnClass(expression);
 	}

 	@Test
-	void testMatchAnnotationOnClassWithSubpackageWildcard() throws Exception {
+	public void testMatchAnnotationOnClassWithSubpackageWildcard() throws Exception {
 		String expression = "within(@(test.annotation..*) *)";
 		AspectJExpressionPointcut springAnnotatedPc = testMatchAnnotationOnClass(expression);
 		assertThat(springAnnotatedPc.matches(TestBean.class.getMethod("setName", String.class), TestBean.class)).isFalse();
@@ -371,7 +382,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testMatchAnnotationOnClassWithExactPackageWildcard() throws Exception {
+	public void testMatchAnnotationOnClassWithExactPackageWildcard() throws Exception {
 		String expression = "within(@(test.annotation.transaction.*) *)";
 		testMatchAnnotationOnClass(expression);
 	}
@@ -389,7 +400,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testAnnotationOnMethodWithFQN() throws Exception {
+	public void testAnnotationOnMethodWithFQN() throws Exception {
 		String expression = "@annotation(test.annotation.transaction.Tx)";
 		AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
 		ajexp.setExpression(expression);
@@ -403,7 +414,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testAnnotationOnCglibProxyMethod() throws Exception {
+	public void testAnnotationOnCglibProxyMethod() throws Exception {
 		String expression = "@annotation(test.annotation.transaction.Tx)";
 		AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
 		ajexp.setExpression(expression);
@@ -414,8 +425,9 @@ class AspectJExpressionPointcutTests {
 		assertThat(ajexp.matches(BeanA.class.getMethod("getAge"), proxy.getClass())).isTrue();
 	}

+
 	@Test
-	void testNotAnnotationOnCglibProxyMethod() throws Exception {
+	public void testNotAnnotationOnCglibProxyMethod() throws Exception {
 		String expression = "!@annotation(test.annotation.transaction.Tx)";
 		AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
 		ajexp.setExpression(expression);
@@ -427,7 +439,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testAnnotationOnDynamicProxyMethod() throws Exception {
+	public void testAnnotationOnDynamicProxyMethod() throws Exception {
 		String expression = "@annotation(test.annotation.transaction.Tx)";
 		AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
 		ajexp.setExpression(expression);
@@ -439,7 +451,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testNotAnnotationOnDynamicProxyMethod() throws Exception {
+	public void testNotAnnotationOnDynamicProxyMethod() throws Exception {
 		String expression = "!@annotation(test.annotation.transaction.Tx)";
 		AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
 		ajexp.setExpression(expression);
@@ -451,7 +463,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testAnnotationOnMethodWithWildcard() throws Exception {
+	public void testAnnotationOnMethodWithWildcard() throws Exception {
 		String expression = "execution(@(test.annotation..*) * *(..))";
 		AspectJExpressionPointcut anySpringMethodAnnotation = new AspectJExpressionPointcut();
 		anySpringMethodAnnotation.setExpression(expression);
@@ -467,7 +479,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testAnnotationOnMethodArgumentsWithFQN() throws Exception {
+	public void testAnnotationOnMethodArgumentsWithFQN() throws Exception {
 		String expression = "@args(*, test.annotation.EmptySpringAnnotation))";
 		AspectJExpressionPointcut takesSpringAnnotatedArgument2 = new AspectJExpressionPointcut();
 		takesSpringAnnotatedArgument2.setExpression(expression);
@@ -496,7 +508,7 @@ class AspectJExpressionPointcutTests {
 	}

 	@Test
-	void testAnnotationOnMethodArgumentsWithWildcards() throws Exception {
+	public void testAnnotationOnMethodArgumentsWithWildcards() throws Exception {
 		String expression = "execution(* *(*, @(test..*) *))";
 		AspectJExpressionPointcut takesSpringAnnotatedArgument2 = new AspectJExpressionPointcut();
 		takesSpringAnnotatedArgument2.setExpression(expression);
@@ -519,15 +531,6 @@ class AspectJExpressionPointcutTests {
 	}


-	public static class OtherIOther implements IOther {
-
-		@Override
-		public void absquatulate() {
-			// Empty
-		}
-	}
-
-
 	public static class HasGeneric {

 		public void setFriends(List<TestBean> friends) {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -28,10 +28,10 @@ import static org.assertj.core.api.Assertions.assertThat;
 * @author Ramnivas Laddad
 * @author Chris Beams
 */
-class BeanNamePointcutMatchingTests {
+public class BeanNamePointcutMatchingTests {

 	@Test
-	void testMatchingPointcuts() {
+	public void testMatchingPointcuts() {
 		assertMatch("someName", "bean(someName)");

 		// Spring bean names are less restrictive compared to AspectJ names (methods, types etc.)
@@ -66,7 +66,7 @@ class BeanNamePointcutMatchingTests {
 	}

 	@Test
-	void testNonMatchingPointcuts() {
+	public void testNonMatchingPointcuts() {
 		assertMisMatch("someName", "bean(someNamex)");
 		assertMisMatch("someName", "bean(someX*Name)");

@@ -87,6 +87,7 @@ class BeanNamePointcutMatchingTests {
 	}

 	private static boolean matches(final String beanName, String pcExpression) {
+		@SuppressWarnings("serial")
 		AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut() {
 			@Override
 			protected String getCurrentProxiedBeanName() {
--- a/Show More
+++ b/Show More