Release v7.0.0-M3

This commit introduces null-safe support for java.util.Optional in the
following SpEL operators:

- PropertyOrFieldReference
- MethodReference
- Indexer
- Projection
- Selection
- Elvis

Specifically, when a null-safe operator is applied to an empty
`Optional`, it will be treated as if the `Optional` were `null`, and
the subsequent operation will evaluate to `null`. However, if a
null-safe operator is applied to a non-empty `Optional`, the subsequent
operation will be applied to the object contained in the `Optional`,
thereby effectively unwrapping the `Optional`.

For example, if `user` is of type `Optional<User>`, the expression
`user?.name` will evaluate to `null` if `user` is either `null` or an
empty `Optional` and will otherwise evaluate to the `name` of the
`user`, effectively `user.get().getName()` for property access.

Note, however, that invocations of methods defined in the `Optional`
API are still supported on an empty `Optional`. For example, if `name`
is of type `Optional<String>`, the expression `name?.orElse('Unknown')`
will evaluate to "Unknown" if `name` is an empty `Optional` and will
otherwise evaluate to the `String` contained in the `Optional` if
`name` is a non-empty `Optional`, effectively `name.get()`.

Closes gh-20433

.github/dco.yml

@@ -0,0 +1,3 @@
+require:
+  members: false
+

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

@@ -2,7 +2,7 @@ name: Build and Deploy Snapshot
 on:
   push:
     branches:
-      - 6.2.x
+      - main
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
 jobs:
@@ -27,7 +27,7 @@ jobs:
             /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
             /**/framework-api-*-docs.zip::zip.type=docs
             /**/framework-api-*-schema.zip::zip.type=schema
-          build-name: 'spring-framework-6.2.x'
+          build-name: 'spring-framework-7.0.x'
           folder: 'deployment-repository'
           password: ${{ secrets.ARTIFACTORY_PASSWORD }}
           repository: 'libs-snapshot-local'

.github/workflows/ci.yml

@@ -1,8 +1,7 @@
 name: CI
 on:
-  push:
-    branches:
-      - 6.2.x
+  schedule:
+    - cron: '30 9 * * *'
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
 jobs:

.github/workflows/release-milestone.yml

@@ -0,0 +1,96 @@
+name: Release Milestone
+on:
+  push:
+    tags:
+      - v7.0.0-M[1-9]
+      - v7.0.0-RC[1-9]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  build-and-stage-release:
+    name: Build and Stage Release
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+      - name: Build and Publish
+        id: build-and-publish
+        uses: ./.github/actions/build
+        with:
+          develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
+          publish: true
+      - name: Stage Release
+        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
+        with:
+          artifact-properties: |
+            /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
+            /**/framework-api-*-docs.zip::zip.type=docs
+            /**/framework-api-*-schema.zip::zip.type=schema
+          build-name: ${{ format('spring-framework-{0}', steps.build-and-publish.outputs.version)}}
+          folder: 'deployment-repository'
+          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+          repository: 'libs-staging-local'
+          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
+          uri: 'https://repo.spring.io'
+          username: ${{ secrets.ARTIFACTORY_USERNAME }}
+    outputs:
+      version: ${{ steps.build-and-publish.outputs.version }}
+  verify:
+    name: Verify
+    needs: build-and-stage-release
+    uses: ./.github/workflows/verify.yml
+    secrets:
+      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
+      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
+    with:
+      staging: true
+      version: ${{ needs.build-and-stage-release.outputs.version }}
+  sync-to-maven-central:
+    name: Sync to Maven Central
+    needs:
+      - build-and-stage-release
+      - verify
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - name: Sync to Maven Central
+        uses: ./.github/actions/sync-to-maven-central
+        with:
+          jfrog-cli-config-token: ${{ secrets.JF_ARTIFACTORY_SPRING }}
+          ossrh-s01-staging-profile: ${{ secrets.OSSRH_S01_STAGING_PROFILE }}
+          ossrh-s01-token-password: ${{ secrets.OSSRH_S01_TOKEN_PASSWORD }}
+          ossrh-s01-token-username: ${{ secrets.OSSRH_S01_TOKEN_USERNAME }}
+          spring-framework-version: ${{ needs.build-and-stage-release.outputs.version }}
+  promote-release:
+    name: Promote Release
+    needs:
+      - build-and-stage-release
+      - sync-to-maven-central
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up JFrog CLI
+        uses: jfrog/setup-jfrog-cli@dff217c085c17666e8849ebdbf29c8fe5e3995e6 # v4.5.2
+        env:
+          JF_ENV_SPRING: ${{ secrets.JF_ARTIFACTORY_SPRING }}
+      - name: Promote build
+        run: jfrog rt build-promote ${{ format('spring-framework-{0}', needs.build-and-stage-release.outputs.version)}} ${{ github.run_number }} libs-milestone-local
+  create-github-release:
+    name: Create GitHub Release
+    needs:
+      - build-and-stage-release
+      - promote-release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - name: Create GitHub Release
+        uses: ./.github/actions/create-github-release
+        with:
+          milestone: ${{ needs.build-and-stage-release.outputs.version }}
+          pre-release: true
+          token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}

.github/workflows/release.yml

@@ -2,7 +2,7 @@ name: Release
 on:
   push:
     tags:
-      - v6.2.[0-9]+
+      - v7.0.[0-9]+
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
 jobs:

.gitignore

@@ -54,3 +54,4 @@ atlassian-ide-plugin.xml
 cached-antora-playbook.yml
 
 node_modules
+/.kotlin/

.sdkmanrc

@@ -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.13-librca
+java=23.0.1-librca

build.gradle

@@ -3,12 +3,9 @@ plugins {
 	// kotlinVersion is managed in gradle.properties
 	id 'org.jetbrains.kotlin.plugin.serialization' version "${kotlinVersion}" apply false
 	id 'org.jetbrains.dokka' version '1.9.20'
-	id 'com.github.ben-manes.versions' version '0.51.0'
 	id 'com.github.bjornvester.xjc' version '1.8.2' apply false
-	id 'de.undercouch.download' version '5.4.0'
 	id 'io.github.goooler.shadow' version '8.1.8' apply false
 	id 'me.champeau.jmh' version '0.7.2' apply false
-	id 'me.champeau.mrjar' version '0.1.1'
 	id "net.ltgt.errorprone" version "4.1.0" apply false
 }
 
@@ -24,13 +21,6 @@ configure(allprojects) { project ->
 	group = "org.springframework"
 	repositories {
 		mavenCentral()
-		maven {
-			url = "https://repo.spring.io/milestone"
-			content {
-				// Netty 5 optional support
-				includeGroup 'io.projectreactor.netty'
-			}
-		}
 		if (version.contains('-')) {
 			maven { url = "https://repo.spring.io/milestone" }
 		}
@@ -64,7 +54,6 @@ configure([rootProject] + javaProjects) { project ->
 	apply plugin: "java"
 	apply plugin: "java-test-fixtures"
 	apply plugin: 'org.springframework.build.conventions'
-	apply from: "${rootDir}/gradle/toolchains.gradle"
 	apply from: "${rootDir}/gradle/ide.gradle"
 
 	dependencies {
@@ -80,22 +69,14 @@ configure([rootProject] + javaProjects) { project ->
 		testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 		testRuntimeOnly("org.junit.platform:junit-platform-suite-engine")
 		testRuntimeOnly("org.apache.logging.log4j:log4j-core")
-		testRuntimeOnly("org.apache.logging.log4j:log4j-jul")
-		testRuntimeOnly("org.apache.logging.log4j:log4j-slf4j2-impl")
-		// JSR-305 only used for non-required meta-annotations
-		compileOnly("com.google.code.findbugs:jsr305")
-		testCompileOnly("com.google.code.findbugs:jsr305")
 	}
 
 	ext.javadocLinks = [
 			"https://docs.oracle.com/en/java/javase/17/docs/api/",
-			"https://jakarta.ee/specifications/platform/9/apidocs/",
+			"https://jakarta.ee/specifications/platform/11/apidocs/",
 			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
 			"https://eclipse.dev/aspectj/doc/latest/runtime-api/",
 			"https://www.quartz-scheduler.org/api/2.3.0/",
-			"https://fasterxml.github.io/jackson-core/javadoc/2.14/",
-			"https://fasterxml.github.io/jackson-databind/javadoc/2.14/",
-			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.14/",
 			"https://hc.apache.org/httpcomponents-client-5.4.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
@@ -109,7 +90,8 @@ configure([rootProject] + javaProjects) { project ->
 			// Previously there could be a split-package issue between JSR250 and JSR305 javax.annotation packages,
 			// but since 6.0 JSR 250 annotations such as @Resource and @PostConstruct have been replaced by their
 			// JakartaEE equivalents in the jakarta.annotation package.
-			//"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/"
+			//"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/",
+			"https://jspecify.dev/docs/api/"
 	] as String[]
 }
 

buildSrc/README.md

@@ -9,7 +9,18 @@ The `org.springframework.build.conventions` plugin applies all conventions to th
 
 * Configuring the Java compiler, see `JavaConventions`
 * Configuring the Kotlin compiler, see `KotlinConventions`
-* Configuring testing in the build with `TestConventions` 
+* Configuring testing in the build with `TestConventions`
+* Configuring the ArchUnit rules for the project, see `org.springframework.build.architecture.ArchitectureRules`
+
+This plugin also provides a DSL extension to optionally enable Java preview features for
+compiling and testing sources in a module. This can be applied with the following in a
+module build file:
+
+```groovy
+springFramework {
+	enableJavaPreviewFeatures = true
+}
+```
 
 
 ## Build Plugins
@@ -22,6 +33,25 @@ but doesn't affect the classpath of dependent projects.
 This plugin does not provide a `provided` configuration, as the native `compileOnly` and `testCompileOnly`
 configurations are preferred.
 
+### MultiRelease Jar
+
+The `org.springframework.build.multiReleaseJar` plugin configures the project with MultiRelease JAR support.
+It creates a new SourceSet and dedicated tasks for each Java variant considered.
+This can be configured with the DSL, by setting a list of Java variants to configure:
+
+```groovy
+plugins {
+    id 'org.springframework.build.multiReleaseJar'
+}
+
+multiRelease {
+	releaseVersions 21, 24
+}
+```
+
+Note, Java classes will be compiled with the toolchain pre-configured by the project, assuming that its
+Java language version is equal or higher than all variants we consider. Each compilation task will only
+set the "-release" compilation option accordingly to produce the expected bytecode version.
 
 ### RuntimeHints Java Agent
 

buildSrc/build.gradle

@@ -20,14 +20,21 @@ ext {
 dependencies {
 	checkstyle "io.spring.javaformat:spring-javaformat-checkstyle:${javaFormatVersion}"
 	implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
-	implementation "org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}"
-	implementation "org.gradle:test-retry-gradle-plugin:1.5.6"
+	implementation "com.tngtech.archunit:archunit:1.4.0"
+	implementation "org.gradle:test-retry-gradle-plugin:1.6.2"
 	implementation "io.spring.javaformat:spring-javaformat-gradle-plugin:${javaFormatVersion}"
 	implementation "io.spring.nohttp:nohttp-gradle:0.0.11"
+
+	testImplementation("org.assertj:assertj-core:${assertjVersion}")
+	testImplementation("org.junit.jupiter:junit-jupiter:${junitJupiterVersion}")
 }
 
 gradlePlugin {
 	plugins {
+		architecturePlugin {
+			id = "org.springframework.architecture"
+			implementationClass = "org.springframework.build.architecture.ArchitecturePlugin"
+		}
 		conventionsPlugin {
 			id = "org.springframework.build.conventions"
 			implementationClass = "org.springframework.build.ConventionsPlugin"
@@ -36,6 +43,10 @@ gradlePlugin {
 			id = "org.springframework.build.localdev"
 			implementationClass = "org.springframework.build.dev.LocalDevelopmentPlugin"
 		}
+		multiReleasePlugin {
+			id = "org.springframework.build.multiReleaseJar"
+			implementationClass = "org.springframework.build.multirelease.MultiReleaseJarPlugin"
+		}
 		optionalDependenciesPlugin {
 			id = "org.springframework.build.optional-dependencies"
 			implementationClass = "org.springframework.build.optional.OptionalDependenciesPlugin"
@@ -46,3 +57,9 @@ gradlePlugin {
 		}
 	}
 }
+
+test {
+	useJUnitPlatform()
+}
+
+jar.dependsOn check

buildSrc/config/checkstyle/checkstyle.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0"?>
 <!DOCTYPE module PUBLIC "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN" "https://checkstyle.org/dtds/configuration_1_3.dtd">
-<module name="com.puppycrawl.tools.checkstyle.Checker">
+<module name="Checker">
 
 	<!-- Root Checks -->
 	<module name="io.spring.javaformat.checkstyle.check.SpringHeaderCheck">
@@ -12,16 +12,15 @@
 	<module name="com.puppycrawl.tools.checkstyle.checks.NewlineAtEndOfFileCheck"/>
 
 	<!-- TreeWalker Checks -->
-	<module name="com.puppycrawl.tools.checkstyle.TreeWalker">
+	<module name="TreeWalker">
 
 		<!-- Imports -->
-		<module name="com.puppycrawl.tools.checkstyle.checks.imports.UnusedImportsCheck">
-			<property name="processJavadoc" value="true"/>
-		</module>
-
+		<module name="AvoidStarImport"/>
+		<module name="UnusedImports"/>
+		<module name="RedundantImport"/>
 		<!-- Modifiers -->
 		<module name="com.puppycrawl.tools.checkstyle.checks.modifier.ModifierOrderCheck"/>
 
 	</module>
 
-</module>
+</module>

buildSrc/gradle.properties

@@ -1,2 +1,4 @@
 org.gradle.caching=true
 javaFormatVersion=0.0.42
+junitJupiterVersion=5.11.4
+assertjVersion=3.27.3

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

@@ -63,8 +63,8 @@ public class CheckstyleConventions {
 		project.getPlugins().apply(NoHttpPlugin.class);
 		NoHttpExtension noHttp = project.getExtensions().getByType(NoHttpExtension.class);
 		noHttp.setAllowlistFile(project.file("src/nohttp/allowlist.lines"));
-		noHttp.getSource().exclude("**/test-output/**", "**/.settings/**",
-				"**/.classpath", "**/.project", "**/.gradle/**", "**/node_modules/**", "buildSrc/build/**");
+		noHttp.getSource().exclude("**/test-output/**", "**/.settings/**", "**/.classpath",
+				"**/.project", "**/.gradle/**", "**/node_modules/**", "**/spring-jcl/**", "buildSrc/build/**");
 		List<String> buildFolders = List.of("bin", "build", "out");
 		project.allprojects(subproject -> {
 			Path rootPath = project.getRootDir().toPath();

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

@@ -21,12 +21,15 @@ import org.gradle.api.Project;
 import org.gradle.api.plugins.JavaBasePlugin;
 import org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin;
 
+import org.springframework.build.architecture.ArchitecturePlugin;
+
 /**
  * Plugin to apply conventions to projects that are part of Spring Framework's build.
  * Conventions are applied in response to various plugins being applied.
  *
  * <p>When the {@link JavaBasePlugin} is applied, the conventions in {@link CheckstyleConventions},
  * {@link TestConventions} and {@link JavaConventions} are applied.
+ * The {@link ArchitecturePlugin} plugin is also applied.
  * When the {@link KotlinBasePlugin} is applied, the conventions in {@link KotlinConventions}
  * are applied.
  *
@@ -36,6 +39,8 @@ public class ConventionsPlugin implements Plugin<Project> {
 
 	@Override
 	public void apply(Project project) {
+		project.getExtensions().create("springFramework", SpringFrameworkExtension.class);
+		new ArchitecturePlugin().apply(project);
 		new CheckstyleConventions().apply(project);
 		new JavaConventions().apply(project);
 		new KotlinConventions().apply(project);

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,7 +17,6 @@
 package org.springframework.build;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 import org.gradle.api.Plugin;
@@ -42,8 +41,18 @@ public class JavaConventions {
 
 	private static final List<String> TEST_COMPILER_ARGS;
 
+	/**
+	 * The Java version we should use as the JVM baseline for building the project
+	 */
+	private static final JavaLanguageVersion DEFAULT_LANGUAGE_VERSION = JavaLanguageVersion.of(23);
+
+	/**
+	 * The Java version we should use as the baseline for the compiled bytecode (the "-release" compiler argument)
+	 */
+	private static final JavaLanguageVersion DEFAULT_RELEASE_VERSION = JavaLanguageVersion.of(17);
+
 	static {
-		List<String> commonCompilerArgs = Arrays.asList(
+		List<String> commonCompilerArgs = List.of(
 				"-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
 				"-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
 				"-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options",
@@ -51,43 +60,75 @@ public class JavaConventions {
 		);
 		COMPILER_ARGS = new ArrayList<>();
 		COMPILER_ARGS.addAll(commonCompilerArgs);
-		COMPILER_ARGS.addAll(Arrays.asList(
+		COMPILER_ARGS.addAll(List.of(
 				"-Xlint:varargs", "-Xlint:fallthrough", "-Xlint:rawtypes", "-Xlint:deprecation",
 				"-Xlint:unchecked", "-Werror"
 		));
 		TEST_COMPILER_ARGS = new ArrayList<>();
 		TEST_COMPILER_ARGS.addAll(commonCompilerArgs);
-		TEST_COMPILER_ARGS.addAll(Arrays.asList("-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
+		TEST_COMPILER_ARGS.addAll(List.of("-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
 				"-Xlint:-deprecation", "-Xlint:-unchecked"));
 	}
 
 	public void apply(Project project) {
-		project.getPlugins().withType(JavaBasePlugin.class, javaPlugin -> applyJavaCompileConventions(project));
+		project.getPlugins().withType(JavaBasePlugin.class, javaPlugin -> {
+			applyToolchainConventions(project);
+			applyJavaCompileConventions(project);
+		});
 	}
 
 	/**
-	 * Applies the common Java compiler options for main sources, test fixture sources, and
+	 * Configure the Toolchain support for the project.
+	 * @param project the current project
+	 */
+	private static void applyToolchainConventions(Project project) {
+		project.getExtensions().getByType(JavaPluginExtension.class).toolchain(toolchain -> {
+			toolchain.getVendor().set(JvmVendorSpec.BELLSOFT);
+			toolchain.getLanguageVersion().set(DEFAULT_LANGUAGE_VERSION);
+		});
+	}
+
+	/**
+	 * Apply the common Java compiler options for main sources, test fixture sources, and
 	 * test sources.
 	 * @param project the current project
 	 */
 	private void applyJavaCompileConventions(Project project) {
-		project.getExtensions().getByType(JavaPluginExtension.class).toolchain(toolchain -> {
-			toolchain.getVendor().set(JvmVendorSpec.BELLSOFT);
-			toolchain.getLanguageVersion().set(JavaLanguageVersion.of(17));
+		project.afterEvaluate(p -> {
+			p.getTasks().withType(JavaCompile.class)
+					.matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_JAVA_TASK_NAME))
+					.forEach(compileTask -> {
+						compileTask.getOptions().setCompilerArgs(COMPILER_ARGS);
+						compileTask.getOptions().setEncoding("UTF-8");
+						setJavaRelease(compileTask);
+					});
+			p.getTasks().withType(JavaCompile.class)
+					.matching(compileTask -> compileTask.getName().startsWith(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME)
+							|| compileTask.getName().equals("compileTestFixturesJava"))
+					.forEach(compileTask -> {
+						compileTask.getOptions().setCompilerArgs(TEST_COMPILER_ARGS);
+						compileTask.getOptions().setEncoding("UTF-8");
+						setJavaRelease(compileTask);
+					});
+
 		});
-		project.getTasks().withType(JavaCompile.class)
-				.matching(compileTask -> compileTask.getName().equals(JavaPlugin.COMPILE_JAVA_TASK_NAME))
-				.forEach(compileTask -> {
-					compileTask.getOptions().setCompilerArgs(COMPILER_ARGS);
-					compileTask.getOptions().setEncoding("UTF-8");
-				});
-		project.getTasks().withType(JavaCompile.class)
-				.matching(compileTask -> compileTask.getName().equals(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME)
-						|| compileTask.getName().equals("compileTestFixturesJava"))
-				.forEach(compileTask -> {
-					compileTask.getOptions().setCompilerArgs(TEST_COMPILER_ARGS);
-					compileTask.getOptions().setEncoding("UTF-8");
-				});
+	}
+
+	/**
+	 * We should pick the {@link #DEFAULT_RELEASE_VERSION} for all compiled classes,
+	 * unless the current task is compiling multi-release JAR code with a higher version.
+	 */
+	private void setJavaRelease(JavaCompile task) {
+		int defaultVersion = DEFAULT_RELEASE_VERSION.asInt();
+		int releaseVersion = defaultVersion;
+		int compilerVersion = task.getJavaCompiler().get().getMetadata().getLanguageVersion().asInt();
+		for (int version = defaultVersion ; version <= compilerVersion ; version++) {
+			if (task.getName().contains("Java" + version)) {
+				releaseVersion = version;
+				break;
+			}
+		}
+		task.getOptions().getRelease().set(releaseVersion);
 	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2022 the original author or authors.
+ * Copyright 2002-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,15 +16,14 @@
 
 package org.springframework.build;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import org.gradle.api.Project;
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions;
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget;
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion;
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile;
 
 /**
  * @author Brian Clozel
+ * @author Sebastien Deleuze
  */
 public class KotlinConventions {
 
@@ -34,15 +33,19 @@ public class KotlinConventions {
 	}
 
 	private void configure(KotlinCompile compile) {
-		KotlinJvmOptions kotlinOptions = compile.getKotlinOptions();
-		kotlinOptions.setApiVersion("1.7");
-		kotlinOptions.setLanguageVersion("1.7");
-		kotlinOptions.setJvmTarget("17");
-		kotlinOptions.setJavaParameters(true);
-		kotlinOptions.setAllWarningsAsErrors(true);
-		List<String> freeCompilerArgs = new ArrayList<>(compile.getKotlinOptions().getFreeCompilerArgs());
-		freeCompilerArgs.addAll(List.of("-Xsuppress-version-warnings", "-Xjsr305=strict", "-opt-in=kotlin.RequiresOptIn"));
-		compile.getKotlinOptions().setFreeCompilerArgs(freeCompilerArgs);
+		compile.compilerOptions(options -> {
+			options.getApiVersion().set(KotlinVersion.KOTLIN_2_1);
+			options.getLanguageVersion().set(KotlinVersion.KOTLIN_2_1);
+			options.getJvmTarget().set(JvmTarget.JVM_17);
+			options.getJavaParameters().set(true);
+			options.getAllWarningsAsErrors().set(true);
+			options.getFreeCompilerArgs().addAll(
+					"-Xsuppress-version-warnings",
+					"-Xjsr305=strict", // For dependencies using JSR 305
+					"-opt-in=kotlin.RequiresOptIn",
+					"-Xjdk-release=17" // Needed due to https://youtrack.jetbrains.com/issue/KT-49746
+			);
+		});
 	}
 
 }

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2002-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.gradle.api.Project;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.compile.JavaCompile;
+import org.gradle.api.tasks.testing.Test;
+import org.gradle.process.CommandLineArgumentProvider;
+
+public class SpringFrameworkExtension {
+
+	private final Property<Boolean> enableJavaPreviewFeatures;
+
+	public SpringFrameworkExtension(Project project) {
+		this.enableJavaPreviewFeatures = project.getObjects().property(Boolean.class);
+		project.getTasks().withType(JavaCompile.class).configureEach(javaCompile ->
+				javaCompile.getOptions().getCompilerArgumentProviders().add(asArgumentProvider()));
+		project.getTasks().withType(Test.class).configureEach(test ->
+				test.getJvmArgumentProviders().add(asArgumentProvider()));
+
+	}
+
+	public Property<Boolean> getEnableJavaPreviewFeatures() {
+		return this.enableJavaPreviewFeatures;
+	}
+
+	private CommandLineArgumentProvider asArgumentProvider() {
+		return () -> {
+			if (getEnableJavaPreviewFeatures().getOrElse(false)) {
+				return List.of("--enable-preview");
+			}
+			return Collections.emptyList();
+		};
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -54,10 +54,7 @@ class TestConventions {
 		test.include("**/*Tests.class", "**/*Test.class");
 		test.setSystemProperties(Map.of(
 				"java.awt.headless", "true",
-				"io.netty.leakDetection.level", "paranoid",
-				"io.netty5.leakDetectionLevel", "paranoid",
-				"io.netty5.leakDetection.targetRecords", "32",
-				"io.netty5.buffer.lifecycleTracingEnabled", "true"
+				"io.netty.leakDetection.level", "paranoid"
 		));
 		if (project.hasProperty("testGroups")) {
 			test.systemProperty("testGroups", project.getProperties().get("testGroups"));

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

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2002-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.architecture;
+
+import com.tngtech.archunit.core.domain.JavaClasses;
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.lang.EvaluationResult;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+import java.util.List;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.GradleException;
+import org.gradle.api.Task;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.file.FileTree;
+import org.gradle.api.provider.ListProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.IgnoreEmptyDirectories;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.Internal;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.PathSensitive;
+import org.gradle.api.tasks.PathSensitivity;
+import org.gradle.api.tasks.SkipWhenEmpty;
+import org.gradle.api.tasks.TaskAction;
+
+import static org.springframework.build.architecture.ArchitectureRules.allPackagesShouldBeFreeOfTangles;
+import static org.springframework.build.architecture.ArchitectureRules.classesShouldNotImportForbiddenTypes;
+import static org.springframework.build.architecture.ArchitectureRules.javaClassesShouldNotImportKotlinAnnotations;
+import static org.springframework.build.architecture.ArchitectureRules.noClassesShouldCallStringToLowerCaseWithoutLocale;
+import static org.springframework.build.architecture.ArchitectureRules.noClassesShouldCallStringToUpperCaseWithoutLocale;
+import static org.springframework.build.architecture.ArchitectureRules.packageInfoShouldBeNullMarked;
+
+/**
+ * {@link Task} that checks for architecture problems.
+ *
+ * @author Andy Wilkinson
+ * @author Scott Frederick
+ */
+public abstract class ArchitectureCheck extends DefaultTask {
+
+	private FileCollection classes;
+
+	public ArchitectureCheck() {
+		getOutputDirectory().convention(getProject().getLayout().getBuildDirectory().dir(getName()));
+		getProhibitObjectsRequireNonNull().convention(true);
+		getRules().addAll(packageInfoShouldBeNullMarked(),
+				classesShouldNotImportForbiddenTypes(),
+				javaClassesShouldNotImportKotlinAnnotations(),
+				allPackagesShouldBeFreeOfTangles(),
+				noClassesShouldCallStringToLowerCaseWithoutLocale(),
+				noClassesShouldCallStringToUpperCaseWithoutLocale());
+		getRuleDescriptions().set(getRules().map((rules) -> rules.stream().map(ArchRule::getDescription).toList()));
+	}
+
+	@TaskAction
+	void checkArchitecture() throws IOException {
+		JavaClasses javaClasses = new ClassFileImporter()
+				.importPaths(this.classes.getFiles().stream().map(File::toPath).toList());
+		List<EvaluationResult> violations = getRules().get()
+				.stream()
+				.map((rule) -> rule.evaluate(javaClasses))
+				.filter(EvaluationResult::hasViolation)
+				.toList();
+		File outputFile = getOutputDirectory().file("failure-report.txt").get().getAsFile();
+		outputFile.getParentFile().mkdirs();
+		if (!violations.isEmpty()) {
+			StringBuilder report = new StringBuilder();
+			for (EvaluationResult violation : violations) {
+				report.append(violation.getFailureReport());
+				report.append(String.format("%n"));
+			}
+			Files.writeString(outputFile.toPath(), report.toString(), StandardOpenOption.CREATE,
+					StandardOpenOption.TRUNCATE_EXISTING);
+			throw new GradleException("Architecture check failed. See '" + outputFile + "' for details.");
+		}
+		else {
+			outputFile.createNewFile();
+		}
+	}
+
+	public void setClasses(FileCollection classes) {
+		this.classes = classes;
+	}
+
+	@Internal
+	public FileCollection getClasses() {
+		return this.classes;
+	}
+
+	@InputFiles
+	@SkipWhenEmpty
+	@IgnoreEmptyDirectories
+	@PathSensitive(PathSensitivity.RELATIVE)
+	final FileTree getInputClasses() {
+		return this.classes.getAsFileTree();
+	}
+
+	@Optional
+	@InputFiles
+	@PathSensitive(PathSensitivity.RELATIVE)
+	public abstract DirectoryProperty getResourcesDirectory();
+
+	@OutputDirectory
+	public abstract DirectoryProperty getOutputDirectory();
+
+	@Internal
+	public abstract ListProperty<ArchRule> getRules();
+
+	@Internal
+	public abstract Property<Boolean> getProhibitObjectsRequireNonNull();
+
+	@Input
+	// The rules themselves can't be an input as they aren't serializable so we use
+	// their descriptions instead
+	abstract ListProperty<String> getRuleDescriptions();
+}

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2002-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.architecture;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.Task;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaPluginExtension;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.TaskProvider;
+import org.gradle.language.base.plugins.LifecycleBasePlugin;
+
+/**
+ * {@link Plugin} for verifying a project's architecture.
+ *
+ * @author Andy Wilkinson
+ */
+public class ArchitecturePlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> registerTasks(project));
+	}
+
+	private void registerTasks(Project project) {
+		JavaPluginExtension javaPluginExtension = project.getExtensions().getByType(JavaPluginExtension.class);
+		List<TaskProvider<ArchitectureCheck>> architectureChecks = new ArrayList<>();
+		for (SourceSet sourceSet : javaPluginExtension.getSourceSets()) {
+			if (sourceSet.getName().contains("test")) {
+				// skip test source sets.
+				continue;
+			}
+			TaskProvider<ArchitectureCheck> checkArchitecture = project.getTasks()
+					.register(taskName(sourceSet), ArchitectureCheck.class,
+							(task) -> {
+								task.setClasses(sourceSet.getOutput().getClassesDirs());
+								task.getResourcesDirectory().set(sourceSet.getOutput().getResourcesDir());
+								task.dependsOn(sourceSet.getProcessResourcesTaskName());
+								task.setDescription("Checks the architecture of the classes of the " + sourceSet.getName()
+										+ " source set.");
+								task.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
+							});
+			architectureChecks.add(checkArchitecture);
+		}
+		if (!architectureChecks.isEmpty()) {
+			TaskProvider<Task> checkTask = project.getTasks().named(LifecycleBasePlugin.CHECK_TASK_NAME);
+			checkTask.configure((check) -> check.dependsOn(architectureChecks));
+		}
+	}
+
+	private static String taskName(SourceSet sourceSet) {
+		return "checkArchitecture"
+				+ sourceSet.getName().substring(0, 1).toUpperCase()
+				+ sourceSet.getName().substring(1);
+	}
+
+}

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

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2002-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.architecture;
+
+import com.tngtech.archunit.base.DescribedPredicate;
+import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.lang.syntax.ArchRuleDefinition;
+import com.tngtech.archunit.library.dependencies.SliceAssignment;
+import com.tngtech.archunit.library.dependencies.SliceIdentifier;
+import com.tngtech.archunit.library.dependencies.SlicesRuleDefinition;
+import java.util.List;
+
+abstract class ArchitectureRules {
+
+	static ArchRule allPackagesShouldBeFreeOfTangles() {
+		return SlicesRuleDefinition.slices()
+				.assignedFrom(new SpringSlices()).should().beFreeOfCycles();
+	}
+
+	static ArchRule noClassesShouldCallStringToLowerCaseWithoutLocale() {
+		return ArchRuleDefinition.noClasses()
+				.should()
+				.callMethod(String.class, "toLowerCase")
+				.because("String.toLowerCase(Locale.ROOT) should be used instead");
+	}
+
+	static ArchRule noClassesShouldCallStringToUpperCaseWithoutLocale() {
+		return ArchRuleDefinition.noClasses()
+				.should()
+				.callMethod(String.class, "toUpperCase")
+				.because("String.toUpperCase(Locale.ROOT) should be used instead");
+	}
+
+	static ArchRule packageInfoShouldBeNullMarked() {
+		return ArchRuleDefinition.classes()
+				.that().haveSimpleName("package-info")
+				.should().beAnnotatedWith("org.jspecify.annotations.NullMarked")
+				.allowEmptyShould(true);
+	}
+
+	static ArchRule classesShouldNotImportForbiddenTypes() {
+		return ArchRuleDefinition.noClasses()
+				.should().dependOnClassesThat()
+				.haveFullyQualifiedName("reactor.core.support.Assert")
+				.orShould().dependOnClassesThat()
+				.haveFullyQualifiedName("org.slf4j.LoggerFactory")
+				.orShould().dependOnClassesThat()
+				.haveFullyQualifiedName("org.springframework.lang.NonNull")
+				.orShould().dependOnClassesThat()
+				.haveFullyQualifiedName("org.springframework.lang.Nullable");
+	}
+
+	static ArchRule javaClassesShouldNotImportKotlinAnnotations() {
+		return ArchRuleDefinition.noClasses()
+				.that(new DescribedPredicate<JavaClass>("is not a Kotlin class") {
+						  @Override
+						  public boolean test(JavaClass javaClass) {
+							  return javaClass.getSourceCodeLocation()
+									  .getSourceFileName().endsWith(".java");
+						  }
+					  }
+				)
+				.should().dependOnClassesThat()
+				.resideInAnyPackage("org.jetbrains.annotations..")
+				.allowEmptyShould(true);
+	}
+
+	static class SpringSlices implements SliceAssignment {
+
+		private final List<String> ignoredPackages = List.of("org.springframework.asm",
+				"org.springframework.cglib",
+				"org.springframework.javapoet",
+				"org.springframework.objenesis");
+
+		@Override
+		public SliceIdentifier getIdentifierOf(JavaClass javaClass) {
+
+			String packageName = javaClass.getPackageName();
+			for (String ignoredPackage : ignoredPackages) {
+				if (packageName.startsWith(ignoredPackage)) {
+					return SliceIdentifier.ignore();
+				}
+			}
+			return SliceIdentifier.of("spring framework");
+		}
+
+		@Override
+		public String getDescription() {
+			return "Spring Framework Slices";
+		}
+	}
+}

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

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2002-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.multirelease;
+
+import javax.inject.Inject;
+
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.artifacts.dsl.DependencyHandler;
+import org.gradle.api.attributes.LibraryElements;
+import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.java.archives.Attributes;
+import org.gradle.api.model.ObjectFactory;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.SourceSetContainer;
+import org.gradle.api.tasks.TaskContainer;
+import org.gradle.api.tasks.TaskProvider;
+import org.gradle.api.tasks.bundling.Jar;
+import org.gradle.api.tasks.compile.JavaCompile;
+import org.gradle.api.tasks.testing.Test;
+import org.gradle.language.base.plugins.LifecycleBasePlugin;
+
+/**
+ * @author Cedric Champeau
+ * @author Brian Clozel
+ */
+public abstract class MultiReleaseExtension {
+	private final TaskContainer tasks;
+	private final SourceSetContainer sourceSets;
+	private final DependencyHandler dependencies;
+	private final ObjectFactory objects;
+	private final ConfigurationContainer configurations;
+
+	@Inject
+	public MultiReleaseExtension(SourceSetContainer sourceSets,
+								 ConfigurationContainer configurations,
+								 TaskContainer tasks,
+								 DependencyHandler dependencies,
+								 ObjectFactory objectFactory) {
+		this.sourceSets = sourceSets;
+		this.configurations = configurations;
+		this.tasks = tasks;
+		this.dependencies = dependencies;
+		this.objects = objectFactory;
+	}
+
+	public void releaseVersions(int... javaVersions) {
+		releaseVersions("src/main/", "src/test/", javaVersions);
+	}
+
+	private void releaseVersions(String mainSourceDirectory, String testSourceDirectory, int... javaVersions) {
+		for (int javaVersion : javaVersions) {
+			addLanguageVersion(javaVersion, mainSourceDirectory, testSourceDirectory);
+		}
+	}
+
+	private void addLanguageVersion(int javaVersion, String mainSourceDirectory, String testSourceDirectory) {
+		String javaN = "java" + javaVersion;
+
+		SourceSet langSourceSet = sourceSets.create(javaN, srcSet -> srcSet.getJava().srcDir(mainSourceDirectory + javaN));
+		SourceSet testSourceSet = sourceSets.create(javaN + "Test", srcSet -> srcSet.getJava().srcDir(testSourceDirectory + javaN));
+		SourceSet sharedSourceSet = sourceSets.findByName(SourceSet.MAIN_SOURCE_SET_NAME);
+		SourceSet sharedTestSourceSet = sourceSets.findByName(SourceSet.TEST_SOURCE_SET_NAME);
+
+		FileCollection mainClasses = objects.fileCollection().from(sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).getOutput().getClassesDirs());
+		dependencies.add(javaN + "Implementation", mainClasses);
+
+		tasks.named(langSourceSet.getCompileJavaTaskName(), JavaCompile.class, task ->
+				task.getOptions().getRelease().set(javaVersion)
+		);
+		tasks.named(testSourceSet.getCompileJavaTaskName(), JavaCompile.class, task ->
+				task.getOptions().getRelease().set(javaVersion)
+		);
+
+		TaskProvider<Test> testTask = createTestTask(javaVersion, testSourceSet, sharedTestSourceSet, langSourceSet, sharedSourceSet);
+		tasks.named("check", task -> task.dependsOn(testTask));
+
+		configureMultiReleaseJar(javaVersion, langSourceSet);
+	}
+
+	private TaskProvider<Test> createTestTask(int javaVersion, SourceSet testSourceSet, SourceSet sharedTestSourceSet, SourceSet langSourceSet, SourceSet sharedSourceSet) {
+		Configuration testImplementation = configurations.getByName(testSourceSet.getImplementationConfigurationName());
+		testImplementation.extendsFrom(configurations.getByName(sharedTestSourceSet.getImplementationConfigurationName()));
+		Configuration testCompileOnly = configurations.getByName(testSourceSet.getCompileOnlyConfigurationName());
+		testCompileOnly.extendsFrom(configurations.getByName(sharedTestSourceSet.getCompileOnlyConfigurationName()));
+		testCompileOnly.getDependencies().add(dependencies.create(langSourceSet.getOutput().getClassesDirs()));
+		testCompileOnly.getDependencies().add(dependencies.create(sharedSourceSet.getOutput().getClassesDirs()));
+
+		Configuration testRuntimeClasspath = configurations.getByName(testSourceSet.getRuntimeClasspathConfigurationName());
+		// so here's the deal. MRjars are JARs! Which means that to execute tests, we need
+		// the JAR on classpath, not just classes + resources as Gradle usually does
+		testRuntimeClasspath.getAttributes()
+				.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.class, LibraryElements.JAR));
+
+		TaskProvider<Test> testTask = tasks.register("java" + javaVersion + "Test", Test.class, test -> {
+			test.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
+
+			ConfigurableFileCollection testClassesDirs = objects.fileCollection();
+			testClassesDirs.from(testSourceSet.getOutput());
+			testClassesDirs.from(sharedTestSourceSet.getOutput());
+			test.setTestClassesDirs(testClassesDirs);
+			ConfigurableFileCollection classpath = objects.fileCollection();
+			// must put the MRJar first on classpath
+			classpath.from(tasks.named("jar"));
+			// then we put the specific test sourceset tests, so that we can override
+			// the shared versions
+			classpath.from(testSourceSet.getOutput());
+
+			// then we add the shared tests
+			classpath.from(sharedTestSourceSet.getRuntimeClasspath());
+			test.setClasspath(classpath);
+		});
+		return testTask;
+	}
+
+	private void configureMultiReleaseJar(int version, SourceSet languageSourceSet) {
+		tasks.named("jar", Jar.class, jar -> {
+			jar.into("META-INF/versions/" + version, s -> s.from(languageSourceSet.getOutput()));
+			Attributes attributes = jar.getManifest().getAttributes();
+			attributes.put("Multi-Release", "true");
+		});
+	}
+
+}

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

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2002-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.multirelease;
+
+import javax.inject.Inject;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.ConfigurationContainer;
+import org.gradle.api.artifacts.dsl.DependencyHandler;
+import org.gradle.api.model.ObjectFactory;
+import org.gradle.api.plugins.ExtensionContainer;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaPluginExtension;
+import org.gradle.api.tasks.TaskContainer;
+import org.gradle.jvm.toolchain.JavaToolchainService;
+
+/**
+ * A plugin which adds support for building multi-release jars
+ * with Gradle.
+ * @author Cedric Champeau
+ * @author Brian Clozel
+ * @see <a href="https://github.com/melix/mrjar-gradle-plugin">original project</a>
+ */
+public class MultiReleaseJarPlugin implements Plugin<Project> {
+
+	@Inject
+	protected JavaToolchainService getToolchains() {
+		throw new UnsupportedOperationException();
+	}
+
+	public void apply(Project project) {
+		project.getPlugins().apply(JavaPlugin.class);
+		ExtensionContainer extensions = project.getExtensions();
+		JavaPluginExtension javaPluginExtension = extensions.getByType(JavaPluginExtension.class);
+		ConfigurationContainer configurations = project.getConfigurations();
+		TaskContainer tasks = project.getTasks();
+		DependencyHandler dependencies = project.getDependencies();
+		ObjectFactory objects = project.getObjects();
+		extensions.create("multiRelease", MultiReleaseExtension.class,
+				javaPluginExtension.getSourceSets(),
+				configurations,
+				tasks,
+				dependencies,
+				objects);
+	}
+}

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

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2002-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.multirelease;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.jar.Attributes;
+import java.util.jar.JarFile;
+import org.gradle.testkit.runner.BuildResult;
+import org.gradle.testkit.runner.GradleRunner;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link MultiReleaseJarPlugin}
+ */
+public class MultiReleaseJarPluginTests {
+
+	private File projectDir;
+
+	private File buildFile;
+
+	@BeforeEach
+	void setup(@TempDir File projectDir) {
+		this.projectDir = projectDir;
+		this.buildFile = new File(this.projectDir, "build.gradle");
+	}
+
+	@Test
+	void configureSourceSets() throws IOException {
+		writeBuildFile("""
+				plugins {
+					id 'java'
+					id 'org.springframework.build.multiReleaseJar'
+				}
+				multiRelease { releaseVersions 21, 24 }
+				task printSourceSets {
+					doLast {
+						sourceSets.all { println it.name }
+					}
+				}
+				""");
+		BuildResult buildResult = runGradle("printSourceSets");
+		assertThat(buildResult.getOutput()).contains("main", "test", "java21", "java21Test", "java24", "java24Test");
+	}
+
+	@Test
+	void configureToolchainReleaseVersion() throws IOException {
+		writeBuildFile("""
+				plugins {
+					id 'java'
+					id 'org.springframework.build.multiReleaseJar'
+				}
+				multiRelease { releaseVersions 21 }
+				task printReleaseVersion {
+					doLast {
+						tasks.all { println it.name }
+						tasks.named("compileJava21Java") {
+							println "compileJava21Java releaseVersion: ${it.options.release.get()}"
+						}
+						tasks.named("compileJava21TestJava") {
+							println "compileJava21TestJava releaseVersion: ${it.options.release.get()}"
+						}
+					}
+				}
+				""");
+
+		BuildResult buildResult = runGradle("printReleaseVersion");
+		assertThat(buildResult.getOutput()).contains("compileJava21Java releaseVersion: 21")
+				.contains("compileJava21TestJava releaseVersion: 21");
+	}
+
+	@Test
+	void packageInJar() throws IOException {
+		writeBuildFile("""
+				plugins {
+					id 'java'
+					id 'org.springframework.build.multiReleaseJar'
+				}
+				version = '1.2.3'
+				multiRelease { releaseVersions 17 }
+				""");
+		writeClass("src/main/java17", "Main.java", """
+				public class Main {}
+				""");
+		BuildResult buildResult = runGradle("assemble");
+		File file = new File(this.projectDir, "/build/libs/" + this.projectDir.getName() + "-1.2.3.jar");
+		assertThat(file).exists();
+		try (JarFile jar = new JarFile(file)) {
+			Attributes mainAttributes = jar.getManifest().getMainAttributes();
+			assertThat(mainAttributes.getValue("Multi-Release")).isEqualTo("true");
+
+			assertThat(jar.entries().asIterator()).toIterable()
+					.anyMatch(entry -> entry.getName().equals("META-INF/versions/17/Main.class"));
+		}
+	}
+
+	private void writeBuildFile(String buildContent) throws IOException {
+		try (PrintWriter out = new PrintWriter(new FileWriter(this.buildFile))) {
+			out.print(buildContent);
+		}
+	}
+
+	private void writeClass(String path, String fileName, String fileContent) throws IOException {
+		Path folder = this.projectDir.toPath().resolve(path);
+		Files.createDirectories(folder);
+		Path filePath = folder.resolve(fileName);
+		Files.createFile(filePath);
+		Files.writeString(filePath, fileContent);
+	}
+
+	private BuildResult runGradle(String... args) {
+		return GradleRunner.create().withProjectDir(this.projectDir).withArguments(args).withPluginClasspath().build();
+	}
+
+}

framework-docs/framework-docs.gradle

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
+
 plugins {
 	id 'kotlin'
 	id 'io.spring.antora.generate-antora-yml' version '0.0.1'
@@ -41,6 +43,11 @@ repositories {
 	}
 }
 
+// To avoid a redeclaration error with Kotlin compiler
+tasks.named('compileKotlin', KotlinCompilationTask.class) {
+    javaSources.from = []
+}
+
 dependencies {
 	api(project(":spring-aspects"))
 	api(project(":spring-context"))
@@ -62,6 +69,7 @@ dependencies {
 	api("jakarta.servlet:jakarta.servlet-api")
 	api("jakarta.resource:jakarta.resource-api")
 	api("jakarta.validation:jakarta.validation-api")
+	api("jakarta.websocket:jakarta.websocket-client-api")
 	api("javax.cache:cache-api")
 	api("org.apache.activemq:activemq-ra:6.1.2")
 	api("org.apache.commons:commons-dbcp2:2.11.0")

framework-docs/modules/ROOT/nav.adoc

@@ -32,6 +32,7 @@
 **** xref:core/beans/java/bean-annotation.adoc[]
 **** xref:core/beans/java/configuration-annotation.adoc[]
 **** xref:core/beans/java/composing-configuration-classes.adoc[]
+**** xref:core/beans/java/programmatic-bean-registration.adoc[]
 *** xref:core/beans/environment.adoc[]
 *** xref:core/beans/context-load-time-weaver.adoc[]
 *** xref:core/beans/context-introduction.adoc[]
@@ -101,7 +102,6 @@
 *** xref:core/aop-api/extensibility.adoc[]
 ** xref:core/null-safety.adoc[]
 ** xref:core/databuffer-codec.adoc[]
-** xref:core/spring-jcl.adoc[]
 ** xref:core/aot.adoc[]
 ** xref:core/appendix.adoc[]
 *** xref:core/appendix/xsd-schemas.adoc[]
@@ -161,7 +161,6 @@
 **** xref:web/webmvc/mvc-servlet/exceptionhandlers.adoc[]
 **** xref:web/webmvc/mvc-servlet/viewresolver.adoc[]
 **** xref:web/webmvc/mvc-servlet/localeresolver.adoc[]
-**** xref:web/webmvc/mvc-servlet/themeresolver.adoc[]
 **** xref:web/webmvc/mvc-servlet/multipart.adoc[]
 **** xref:web/webmvc/mvc-servlet/logging.adoc[]
 *** xref:web/webmvc/filters.adoc[]

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

@@ -206,18 +206,17 @@ another file or files. The following example shows how to do so:
 	<beans>
 		<import resource="services.xml"/>
 		<import resource="resources/messageSource.xml"/>
-		<import resource="/resources/themeSource.xml"/>
 
 		<bean id="bean1" class="..."/>
 		<bean id="bean2" class="..."/>
 	</beans>
 ----
 
-In the preceding example, external bean definitions are loaded from three files:
-`services.xml`, `messageSource.xml`, and `themeSource.xml`. All location paths are
+In the preceding example, external bean definitions are loaded from the files
+`services.xml` and `messageSource.xml`. All location paths are
 relative to the definition file doing the importing, so `services.xml` must be in the
 same directory or classpath location as the file doing the importing, while
-`messageSource.xml` and `themeSource.xml` must be in a `resources` location below the
+`messageSource.xml` must be in a `resources` location below the
 location of the importing file. As you can see, a leading slash is ignored. However, given
 that these paths are relative, it is better form not to use the slash at all. The
 contents of the files being imported, including the top level `<beans/>` element, must

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

@@ -674,9 +674,7 @@ By default, the `AnnotationBeanNameGenerator` is used. For Spring
 xref:core/beans/classpath-scanning.adoc#beans-stereotype-annotations[stereotype annotations],
 if you supply a name via the annotation's `value` attribute that name will be used as
 the name in the corresponding bean definition. This convention also applies when the
-following JSR-250 and JSR-330 annotations are used instead of Spring stereotype
-annotations: `@jakarta.annotation.ManagedBean`, `@javax.annotation.ManagedBean`,
-`@jakarta.inject.Named`, and `@javax.inject.Named`.
+`@jakarta.inject.Named` annotation is used instead of Spring stereotype annotations.
 
 As of Spring Framework 6.1, the name of the annotation attribute that is used to specify
 the bean name is no longer required to be `value`. Custom stereotype annotations can

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

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

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

@@ -1,19 +1,19 @@
 [[expressions-operator-elvis]]
 = The Elvis Operator
 
-The Elvis operator is a shortening of the ternary operator syntax and is used in the
-https://www.groovy-lang.org/operators.html#_elvis_operator[Groovy] language.
-With the ternary operator syntax, you usually have to repeat a variable twice, as the
-following example shows:
+The Elvis operator (`?:`) is a shortening of the ternary operator syntax and is used in
+the https://www.groovy-lang.org/operators.html#_elvis_operator[Groovy] language. With the
+ternary operator syntax, you often have to repeat a variable twice, as the following Java
+example shows:
 
-[source,groovy,indent=0,subs="verbatim,quotes"]
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	String name = "Elvis Presley";
 	String displayName = (name != null ? name : "Unknown");
 ----
 
 Instead, you can use the Elvis operator (named for the resemblance to Elvis' hair style).
-The following example shows how to use the Elvis operator:
+The following example shows how to use the Elvis operator in a SpEL expression:
 
 [tabs]
 ======
@@ -23,7 +23,7 @@ Java::
 ----
 	ExpressionParser parser = new SpelExpressionParser();
 
-	String name = parser.parseExpression("name?:'Unknown'").getValue(new Inventor(), String.class);
+	String name = parser.parseExpression("name ?: 'Unknown'").getValue(new Inventor(), String.class);
 	System.out.println(name);  // 'Unknown'
 ----
 
@@ -33,14 +33,29 @@ Kotlin::
 ----
 	val parser = SpelExpressionParser()
 
-	val name = parser.parseExpression("name?:'Unknown'").getValue(Inventor(), String::class.java)
+	val name = parser.parseExpression("name ?: 'Unknown'").getValue(Inventor(), String::class.java)
 	println(name)  // 'Unknown'
 ----
 ======
 
-NOTE: The SpEL Elvis operator also checks for _empty_ Strings in addition to `null` objects.
-The original snippet is thus only close to emulating the semantics of the operator (it would need an
-additional `!name.isEmpty()` check).
+[NOTE]
+====
+The SpEL Elvis operator also treats an _empty_ String like a `null` object. Thus, the
+original Java example is only close to emulating the semantics of the operator: it would
+need to use `name != null && !name.isEmpty()` as the predicate to be compatible with the
+semantics of the SpEL Elvis operator.
+====
+
+[TIP]
+====
+As of Spring Framework 7.0, the SpEL Elvis operator supports `java.util.Optional` with
+transparent unwrapping semantics.
+
+For example, given the expression `A ?: B`, if `A` is `null` or an _empty_ `Optional`,
+the expression evaluates to `B`. However, if `A` is a non-empty `Optional` the expression
+evaluates to the object contained in the `Optional`, thereby effectively unwrapping the
+`Optional` which correlates to `A.get()`.
+====
 
 The following listing shows a more complex example:
 
@@ -54,11 +69,11 @@ Java::
 	EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
 
 	Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
-	String name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String.class);
+	String name = parser.parseExpression("name ?: 'Elvis Presley'").getValue(context, tesla, String.class);
 	System.out.println(name);  // Nikola Tesla
 
 	tesla.setName("");
-	name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String.class);
+	name = parser.parseExpression("name ?: 'Elvis Presley'").getValue(context, tesla, String.class);
 	System.out.println(name);  // Elvis Presley
 ----
 
@@ -70,16 +85,16 @@ Kotlin::
 	val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
 
 	val tesla = Inventor("Nikola Tesla", "Serbian")
-	var name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String::class.java)
+	var name = parser.parseExpression("name ?: 'Elvis Presley'").getValue(context, tesla, String::class.java)
 	println(name)  // Nikola Tesla
 
 	tesla.setName("")
-	name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String::class.java)
+	name = parser.parseExpression("name ?: 'Elvis Presley'").getValue(context, tesla, String::class.java)
 	println(name)  // Elvis Presley
 ----
 ======
 
-[NOTE]
+[TIP]
 =====
 You can use the Elvis operator to apply default values in expressions. The following
 example shows how to use the Elvis operator in a `@Value` expression:
@@ -89,7 +104,6 @@ example shows how to use the Elvis operator in a `@Value` expression:
 	@Value("#{systemProperties['pop3.port'] ?: 25}")
 ----
 
-This will inject a system property `pop3.port` if it is defined or 25 if not.
+This will inject the value of the system property named `pop3.port` if it is defined or
+`25` if the property is not defined.
 =====
-
-

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

@@ -252,7 +252,6 @@ Kotlin::
 <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 (`?.$`).
 
@@ -351,6 +350,50 @@ Kotlin::
 <2> Use null-safe projection operator on null `members` list
 ======
 
+[[expressions-operator-safe-navigation-optional]]
+== Null-safe Operations on `Optional`
+
+As of Spring Framework 7.0, null-safe operations are supported on instances of
+`java.util.Optional` with transparent unwrapping semantics.
+
+Specifically, when a null-safe operator is applied to an _empty_ `Optional`, it will be
+treated as if the `Optional` were `null`, and the subsequent operation will evaluate to
+`null`. However, if a null-safe operator is applied to a non-empty `Optional`, the
+subsequent operation will be applied to the object contained in the `Optional`, thereby
+effectively unwrapping the `Optional`.
+
+For example, if `user` is of type `Optional<User>`, the expression `user?.name` will
+evaluate to `null` if `user` is either `null` or an _empty_ `Optional` and will otherwise
+evaluate to the `name` of the `user`, effectively `user.get().getName()` or
+`user.get().name` for property or field access, respectively.
+
+[NOTE]
+====
+Invocations of methods defined in the `Optional` API are still supported on an _empty_
+`Optional`. For example, if `name` is of type `Optional<String>`, the expression
+`name?.orElse('Unknown')` will evaluate to `"Unknown"` if `name` is an empty `Optional`
+and will otherwise evaluate to the `String` contained in the `Optional` if `name` is a
+non-empty `Optional`, effectively `name.get()`.
+====
+
+// NOTE: &#8288; is the Unicode Character 'WORD JOINER', which prevents undesired line wraps.
+
+Similarly, if `names` is of type `Optional<List<String>>`, the expression
+`names?.?&#8288;[#this.length > 5]` will evaluate to `null` if `names` is `null` or an _empty_
+`Optional` and will otherwise evaluate to a sequence containing the names whose lengths
+are greater than 5, effectively
+`names.get().stream().filter(s -> s.length() > 5).toList()`.
+
+The same semantics apply to all of the null-safe operators mentioned previously in this
+chapter.
+
+For further details and examples, consult the javadoc for the following operators.
+
+* {spring-framework-api}/expression/spel/ast/PropertyOrFieldReference.html[`PropertyOrFieldReference`]
+* {spring-framework-api}/expression/spel/ast/MethodReference.html[`MethodReference`]
+* {spring-framework-api}/expression/spel/ast/Indexer.html[`Indexer`]
+* {spring-framework-api}/expression/spel/ast/Selection.html[`Selection`]
+* {spring-framework-api}/expression/spel/ast/Projection.html[`Projection`]
 
 [[expressions-operator-safe-navigation-compound-expressions]]
 == Null-safe Operations in Compound Expressions

framework-docs/modules/ROOT/pages/core/null-safety.adoc

@@ -1,57 +1,184 @@
 [[null-safety]]
 = Null-safety
 
-Although Java does not let you express null-safety with its type system, the Spring Framework
-provides the following annotations in the `org.springframework.lang` package to let you
-declare nullability of APIs and fields:
+Although Java does not let you express null-safety with its type system, the Spring Framework codebase is annotated with
+https://jspecify.dev/docs/start-here/[JSpecify] annotations to declare the nullness of APIs, fields and related type
+usages. Reading the https://jspecify.dev/docs/user-guide/[JSpecify user guide] is highly recommended in order to get
+familiar with those annotations and semantics.
 
-* {spring-framework-api}/lang/Nullable.html[`@Nullable`]: Annotation to indicate that a
-specific parameter, return value, or field can be `null`.
-* {spring-framework-api}/lang/NonNull.html[`@NonNull`]: Annotation to indicate that a specific
-parameter, return value, or field cannot be `null` (not needed on parameters, return values,
-and fields where `@NonNullApi` and `@NonNullFields` apply, respectively).
-* {spring-framework-api}/lang/NonNullApi.html[`@NonNullApi`]: Annotation at the package level
-that declares non-null as the default semantics for parameters and return values.
-* {spring-framework-api}/lang/NonNullFields.html[`@NonNullFields`]: Annotation at the package
-level that declares non-null as the default semantics for fields.
+The primary goal of this explicit null-safety arrangement is to prevent `NullPointerException` to be thrown at runtime via
+build time checks and to turn explicit nullness into a way to express the possible absence of value. It is useful in
+both Java by leveraging some tooling (https://github.com/uber/NullAway[NullAway] or IDEs supporting null-safety
+annotations such as IntelliJ IDEA or Eclipse) and Kotlin where JSpecify annotations are automatically translated to
+{kotlin-docs}/null-safety.html[Kotlin's null safety].
 
-The Spring Framework itself leverages these annotations, but they can also be used in any
-Spring-based Java project to declare null-safe APIs and optionally null-safe fields.
-Nullability declarations for generic type arguments, varargs, and array elements are not supported yet.
-Nullability declarations are expected to be fine-tuned between Spring Framework releases,
-including minor ones. Nullability of types used inside method bodies is outside the
-scope of this feature.
+The {spring-framework-api}/core/Nullness.html[`Nullness` Spring API] can be used at runtime to detect the nullness of a
+type usage, a field, a method return type or a parameter. It provides full support for JSpecify annotations,
+Kotlin null safety, Java primitive types, as well as a pragmatic check on any `@Nullable` annotation (regardless of the
+package).
 
-NOTE: Other common libraries such as Reactor and Spring Data provide null-safe APIs that
-use a similar nullability arrangement, delivering a consistent overall experience for
-Spring application developers.
+[[null-safety-libraries]]
+== Annotating libraries with JSpecify annotations
+
+As of Spring Framework 7, the Spring Framework codebase leverages JSpecify annotations to expose null-safe APIs and
+to check the consistency of those null-safety declarations with https://github.com/uber/NullAway[NullAway] as part of
+its build. It is recommended for each library depending on Spring Framework (Spring portfolio projects), as
+well as other libraries related to the Spring ecosystem (Reactor, Micrometer and Spring community projects), to do the
+same.
+
+[[null-safety-applications]]
+== Leveraging JSpecify annotations in Spring applications
+
+Developing applications with IDEs supporting null-safety annotations, such as IntelliJ IDEA or Eclipse, will provide
+warnings in Java and errors in Kotlin when the null-safety contracts are not honored, allowing Spring application
+developers to refine their null handling to prevent `NullPointerException` to be thrown at runtime.
+
+Optionally, Spring application developers can annotate their codebase and use https://github.com/uber/NullAway[NullAway]
+to enforce null-safety during build time at application level.
+
+[[null-safety-guidelines]]
+== Guidelines
+
+The purpose of this section is to share some guidelines proposed for specifying explicitly the nullness of Spring-related
+libraries or applications.
 
 
+[[null-safety-guidelines-jpecify]]
+=== JSpecify
+
+The key points to understand is that by default, the nullness of types is unknown in Java, and that non-null type
+usages are by far more frequent than nullable ones. In order to keep codebases readable, we typically want to define
+that by default, type usages are non-null unless marked as nullable for a specific scope. This is exactly the purpose of
+https://jspecify.dev/docs/api/org/jspecify/annotations/NullMarked.html[`@NullMarked`] that is typically set with Spring
+at package level via a `package-info.java` file, for example:
+
+[source,java,subs="verbatim,quotes",chomp="-packages",fold="none"]
+----
+@NullMarked
+package org.springframework.core;
+
+import org.jspecify.annotations.NullMarked;
+----
+
+In the various Java files belonging to the package, nullable type usages are defined explicitly with
+https://jspecify.dev/docs/api/org/jspecify/annotations/Nullable.html[`@Nullable`]. It is recommended that this
+annotation is specified just before the related type.
+
+For example, for a field:
+
+[source,java,subs="verbatim,quotes"]
+----
+private @Nullable String fileEncoding;
+----
+
+Or for method parameters and return value:
+
+[source,java,subs="verbatim,quotes"]
+----
+public static @Nullable String buildMessage(@Nullable String message,
+                                            @Nullable Throwable cause) {
+    // ...
+}
+----
+
+When overriding a method, nullness annotations are not inherited from the superclass method. That means those
+nullness annotations should be repeated if you just want to override the implementation and keep the same API
+nullness.
+
+With arrays and varargs, you need to be able to differentiate the nullness of the elements from the nullness of
+the array itself. Pay attention to the syntax
+https://docs.oracle.com/javase/specs/jls/se17/html/jls-9.html#jls-9.7.4[defined by the Java specification] which may be
+initially surprising:
+
+- `@Nullable Object[] array` means individual elements can be null but the array itself can't.
+- `Object @Nullable [] array` means individual elements can't be null but the array itself can.
+- `@Nullable Object @Nullable [] array` means both individual elements and the array can be null.
+
+The Java specifications also enforces that annotations defined with `@Target(ElementType.TYPE_USE)` like JSpecify
+`@Nullable` should be specified after the last `.` with inner or fully qualified types:
+
+ - `Cache.@Nullable ValueWrapper`
+ - `jakarta.validation.@Nullable Validator`
+
+https://jspecify.dev/docs/api/org/jspecify/annotations/NonNull.html[`@NonNull`] and
+https://jspecify.dev/docs/api/org/jspecify/annotations/NullUnmarked.html[`@NullUnmarked`] should rarely be needed for
+typical use cases.
+
+[[null-safety-guidelines-nullaway]]
+=== NullAway
+
+==== Configuration
+
+The recommended configuration is:
+
+ - `NullAway:OnlyNullMarked=true` in order to perform nullness checks only for packages annotated with `@NullMarked`.
+ - `NullAway:CustomContractAnnotations=org.springframework.lang.Contract` which makes NullAway aware of the
+{spring-framework-api}/lang/Contract.html[@Contract] annotation in the `org.springframework.lang` package which
+can be used to express complementary semantics to avoid non-relevant null-safety warnings in your codebase.
+
+A good example of `@Contract` benefits is
+{spring-framework-api}/util/Assert.html#notNull(java.lang.Object,java.lang.String)[`Assert#notnull`] which is annotated
+with `@Contract("null, _ -> fail")`. With the configuration above, NullAway will understand that after a successful
+invocation, the value passed as a parameter is not null.
+
+Optionally, it is possible to set `NullAway:JSpecifyMode=true` to enable
+https://github.com/uber/NullAway/wiki/JSpecify-Support[checks on the full JSpecify semantics], including annotations on
+generic types. Be aware that this mode is
+https://github.com/uber/NullAway/issues?q=is%3Aissue+is%3Aopen+label%3Ajspecify[still under development] and requires
+using JDK 22 or later (typically combined with the `--release` Java compiler flag to configure the
+expected baseline). It is recommended to enable the JSpecify mode only as a second step, after making sure the codebase
+generates no warning with the recommended configuration mentioned above.
+
+==== Warnings suppression
+
+There are a few valid use cases where NullAway will wrongly detect nullness problems. In such case, it is recommended
+to suppress related warnings and to document the reason:
+
+ - `@SuppressWarnings("NullAway.Init")` at field, constructor or class level can be used to avoid unnecessary warnings
+due to the lazy initialization of fields, for example due to a class implementing
+{spring-framework-api}/beans/factory/InitializingBean.html[`InitializingBean`].
+ - `@SuppressWarnings("NullAway") // Dataflow analysis limitation` can be used when NullAway dataflow analysis is not
+able to detect that the path involving a nullness problem will never happen.
+ - `@SuppressWarnings("NullAway") // Lambda` can be used when NullAway does not take into account assertions performed
+outside of a lambda for the code path within the lambda.
+- `@SuppressWarnings("NullAway") // Reflection` can be used for some reflection operations that are known returning
+non-null values even if that can't be expressed by the API.
+- `@SuppressWarnings("NullAway") // Well-known map keys` can be used when `Map#get` invocations are done with keys known
+to be present and non-null related values inserted previously.
+- `@SuppressWarnings("NullAway") // Overridden method does not define nullness` can be used when the super class does
+not define nullness (typically when the super class is coming from a dependency).
 
 
-[[use-cases]]
-== Use cases
+[[null-safety-migrating]]
+== Migrating from Spring null-safety annotations
 
-In addition to providing an explicit declaration for Spring Framework API nullability,
-these annotations can be used by an IDE (such as IDEA or Eclipse) to provide useful
-warnings related to null-safety in order to avoid `NullPointerException` at runtime.
+Spring null-safety annotations {spring-framework-api}/lang/Nullable.html[`@Nullable`],
+{spring-framework-api}/lang/NonNull.html[`@NonNull`],
+{spring-framework-api}/lang/NonNullApi.html[`@NonNullApi`], and
+{spring-framework-api}/lang/NonNullFields.html[`@NonNullFields`] in the `org.springframework.lang` package have been
+introduced in Spring Framework 5 when JSpecify did not exist and the best option was to leverage JSR 305 (a dormant
+but widespread JSR) meta-annotations. They are deprecated as of Spring Framework 7 in favor of
+https://jspecify.dev/docs/start-here/[JSpecify] annotations, which provide significant enhancements such as properly
+defined specifications, a canonical dependency with no split-package issue, better tooling, better Kotlin integration
+and the capability to specify the nullness more precisely for more use cases.
 
-They are also used to make Spring APIs null-safe in Kotlin projects, since Kotlin natively
-supports {kotlin-docs}/null-safety.html[null-safety]. More details
-are available in the xref:languages/kotlin/null-safety.adoc[Kotlin support documentation].
+A key difference is that Spring null-safety annotations, following JSR 305 semantics, apply to fields,
+parameters and return values while JSpecify annotations apply to type usages. This subtle difference
+is in practice pretty significant, as it allows for example to differentiate the nullness of elements from the
+nullness of arrays/varargs as well as defining the nullness of generic types.
 
+That means array and varargs null-safety declarations have to be updated to keep the same semantic. For example
+`@Nullable Object[] array` with Spring annotations needs to be changed to `Object @Nullable [] array` with JSpecify
+annotations. Same for varargs.
 
+It is also recommended to move field and return value annotations closer to the type, for example:
 
+ - For fields, instead of `@Nullable private String field` with Spring annotations, use `private @Nullable String field`
+with JSpecify annotations.
+- For return values, instead of `@Nullable public String method()` with Spring annotations, use
+`public @Nullable String method()` with JSpecify annotations.
 
-[[jsr-305-meta-annotations]]
-== JSR-305 meta-annotations
+Also, with JSpecify, you don't need to specify `@NonNull` when overriding a type usage annotated with `@Nullable` in the
+super method to "undo" the nullable declaration in null-marked code. Just declare it unannotated and the null-marked
+defaults (a type usage is considered non-null unless explicitly annotated as nullable) will apply.
 
-Spring annotations are meta-annotated with {JSR}305[JSR 305]
-annotations (a dormant but widespread JSR). JSR-305 meta-annotations let tooling vendors
-like IDEA or Kotlin provide null-safety support in a generic way, without having to
-hard-code support for Spring annotations.
-
-It is neither necessary nor recommended to add a JSR-305 dependency to the project classpath to
-take advantage of Spring's null-safe APIs. Only projects such as Spring-based libraries that use
-null-safety annotations in their codebase should add `com.google.code.findbugs:jsr305:3.0.2`
-with `compileOnly` Gradle configuration or Maven `provided` scope to avoid compiler warnings.

framework-docs/modules/ROOT/pages/core/spring-jcl.adoc

@@ -1,47 +0,0 @@
-[[spring-jcl]]
-= Logging
-
-Spring comes with its own Commons Logging bridge implemented
-in the `spring-jcl` module. The implementation checks for the presence of the Log4j 2.x
-API and the SLF4J 1.7 API in the classpath and uses the first one of those found as the
-logging implementation, falling back to the Java platform's core logging facilities (also
-known as _JUL_ or `java.util.logging`) if neither Log4j 2.x nor SLF4J is available.
-
-Put Log4j 2.x or Logback (or another SLF4J provider) in your classpath, without any extra
-bridges, and let the framework auto-adapt to your choice. For further information see the
-{spring-boot-docs-ref}/features/logging.html[Spring
-Boot Logging Reference Documentation].
-
-[NOTE]
-====
-Spring's Commons Logging variant is only meant to be used for infrastructure logging
-purposes in the core framework and in extensions.
-
-For logging needs within application code, prefer direct use of Log4j 2.x, SLF4J, or JUL.
-====
-
-A `Log` implementation may be retrieved via `org.apache.commons.logging.LogFactory` as in
-the following example.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-public class MyBean {
-	private final Log log = LogFactory.getLog(getClass());
-    // ...
-}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
-----
-class MyBean {
-  private val log = LogFactory.getLog(javaClass)
-  // ...
-}
-----
-======

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

@@ -11,9 +11,7 @@ Spring Framework's email support:
 * The https://jakartaee.github.io/mail-api/[Jakarta Mail] library
 
 This library is freely available on the web -- for example, in Maven Central as
-`com.sun.mail:jakarta.mail`. Please make sure to use the latest 2.x version (which uses
-the `jakarta.mail` package namespace) rather than Jakarta Mail 1.6.x (which uses the
-`javax.mail` package namespace).
+`org.eclipse.angus:angus-mail`.
 ****
 
 The Spring Framework provides a helpful utility library for sending email that shields

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

@@ -1,113 +1,7 @@
 [[kotlin-bean-definition-dsl]]
 = Bean Definition DSL
 
-Spring Framework supports registering beans in a functional way by using lambdas
-as an alternative to XML or Java configuration (`@Configuration` and `@Bean`). In a nutshell,
-it lets you register beans with a lambda that acts as a `FactoryBean`.
-This mechanism is very efficient, as it does not require any reflection or CGLIB proxies.
-
-In Java, you can, for example, write the following:
-
-[source,java,indent=0]
-----
-	class Foo {}
-
-	class Bar {
-		private final Foo foo;
-		public Bar(Foo foo) {
-			this.foo = foo;
-		}
-	}
-
-	GenericApplicationContext context = new GenericApplicationContext();
-	context.registerBean(Foo.class);
-	context.registerBean(Bar.class, () -> new Bar(context.getBean(Foo.class)));
-----
-
-In Kotlin, with reified type parameters and `GenericApplicationContext` Kotlin extensions,
-you can instead write the following:
-
-[source,kotlin,indent=0]
-----
-	class Foo
-
-	class Bar(private val foo: Foo)
-
-	val context = GenericApplicationContext().apply {
-		registerBean<Foo>()
-		registerBean { Bar(it.getBean()) }
-	}
-----
-
-When the class `Bar` has a single constructor, you can even just specify the bean class,
-the constructor parameters will be autowired by type:
-
-[source,kotlin,indent=0]
-----
-	val context = GenericApplicationContext().apply {
-		registerBean<Foo>()
-		registerBean<Bar>()
-	}
-----
-
-In order to allow a more declarative approach and cleaner syntax, Spring Framework provides
-a {spring-framework-api-kdoc}/spring-context/org.springframework.context.support/-bean-definition-dsl/index.html[Kotlin bean definition DSL]
-It declares an `ApplicationContextInitializer` through a clean declarative API,
-which lets you deal with profiles and `Environment` for customizing
-how beans are registered.
-
-In the following example notice that:
-
-* Type inference usually allows to avoid specifying the type for bean references like `ref("bazBean")`
-* It is possible to use Kotlin top level functions to declare beans using callable references like `bean(::myRouter)` in this example
-* When specifying `bean<Bar>()` or `bean(::myRouter)`, parameters are autowired by type
-* The `FooBar` bean will be registered only if the `foobar` profile is active
-
-[source,kotlin,indent=0]
-----
-	class Foo
-	class Bar(private val foo: Foo)
-	class Baz(var message: String = "")
-	class FooBar(private val baz: Baz)
-
-	val myBeans = beans {
-		bean<Foo>()
-		bean<Bar>()
-		bean("bazBean") {
-			Baz().apply {
-				message = "Hello world"
-			}
-		}
-		profile("foobar") {
-			bean { FooBar(ref("bazBean")) }
-		}
-		bean(::myRouter)
-	}
-
-	fun myRouter(foo: Foo, bar: Bar, baz: Baz) = router {
-		// ...
-	}
-----
-
-NOTE: This DSL is programmatic, meaning it allows custom registration logic of beans
-through an `if` expression, a `for` loop, or any other Kotlin constructs.
-
-You can then use this `beans()` function to register beans on the application context,
-as the following example shows:
-
-[source,kotlin,indent=0]
-----
-	val context = GenericApplicationContext().apply {
-		myBeans.initialize(this)
-		refresh()
-	}
-----
-
-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].
+See xref:core/beans/java/programmatic-bean-registration.adoc[Programmatic Bean Registration].
 
 
 

framework-docs/modules/ROOT/pages/languages/kotlin/null-safety.adoc

@@ -5,34 +5,11 @@ One of Kotlin's key features is {kotlin-docs}/null-safety.html[null-safety],
 which cleanly deals with `null` values at compile time rather than bumping into the famous
 `NullPointerException` at runtime. This makes applications safer through nullability
 declarations and expressing "`value or no value`" semantics without paying the cost of wrappers, such as `Optional`.
-(Kotlin allows using functional constructs with nullable values. See this
-{baeldung-blog}/kotlin-null-safety[comprehensive guide to Kotlin null-safety].)
+Kotlin allows using functional constructs with nullable values. See this
+{baeldung-blog}/kotlin-null-safety[comprehensive guide to Kotlin null-safety].
 
 Although Java does not let you express null-safety in its type-system, the Spring Framework
-provides xref:languages/kotlin/null-safety.adoc[null-safety of the whole Spring Framework API]
-via tooling-friendly annotations declared in the `org.springframework.lang` package.
-By default, types from Java APIs used in Kotlin are recognized as
-{kotlin-docs}/java-interop.html#null-safety-and-platform-types[platform types],
-for which null-checks are relaxed.
-{kotlin-docs}/java-interop.html#jsr-305-support[Kotlin support for JSR-305 annotations]
-and Spring nullability annotations provide null-safety for the whole Spring Framework API to Kotlin developers,
-with the advantage of dealing with `null`-related issues at compile time.
-
-NOTE: Libraries such as Reactor or Spring Data provide null-safe APIs to leverage this feature.
-
-You can configure JSR-305 checks by adding the `-Xjsr305` compiler flag with the following
-options: `-Xjsr305={strict|warn|ignore}`.
-
-For kotlin versions 1.1+, the default behavior is the same as `-Xjsr305=warn`.
-The `strict` value is required to have Spring Framework API null-safety taken into account
-in Kotlin types inferred from Spring API but should be used with the knowledge that Spring
-API nullability declaration could evolve even between minor releases and that more checks may
-be added in the future.
-
-NOTE: Generic type arguments, varargs, and array elements nullability are not supported yet,
-but should be in an upcoming release. See {kotlin-github-org}/KEEP/issues/79[this discussion]
-for up-to-date information.
-
-
-
+provides xref:core/null-safety.adoc[null-safety of the whole Spring Framework API]
+via tooling-friendly https://jspecify.dev/[JSpecify] annotations.
 
+As of Kotlin 2.1, Kotlin enforces strict handling of nullability annotations from `org.jspecify.annotations` package.

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

@@ -2,7 +2,7 @@
 = Requirements
 :page-section-summary-toc: 1
 
-Spring Framework supports Kotlin 1.7+ and requires
+Spring Framework supports Kotlin 2.1+ and requires
 https://search.maven.org/artifact/org.jetbrains.kotlin/kotlin-stdlib[`kotlin-stdlib`]
 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

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

@@ -75,66 +75,13 @@ mockMvc.get("/person/{name}", "Lee") {
 
 
 
-[[kotlin-script-templates]]
-== Kotlin Script Templates
-
-Spring Framework provides a
-{spring-framework-api}/web/servlet/view/script/ScriptTemplateView.html[`ScriptTemplateView`]
-which supports {JSR}223[JSR-223] to render templates by using script engines.
-
-By leveraging `scripting-jsr223` dependencies, it
-is possible to use such feature to render Kotlin-based templates with
-{kotlin-github-org}/kotlinx.html[kotlinx.html] DSL or Kotlin multiline interpolated `String`.
-
-`build.gradle.kts`
-[source,kotlin,indent=0]
-----
-dependencies {
-        runtime("org.jetbrains.kotlin:kotlin-scripting-jsr223:${kotlinVersion}")
-}
-----
-
-Configuration is usually done with `ScriptTemplateConfigurer` and `ScriptTemplateViewResolver` beans.
-
-`KotlinScriptConfiguration.kt`
-[source,kotlin,indent=0]
-----
-@Configuration
-class KotlinScriptConfiguration {
-
-    @Bean
-	fun kotlinScriptConfigurer() = ScriptTemplateConfigurer().apply {
-		engineName = "kotlin"
-		setScripts("scripts/render.kts")
-		renderFunction = "render"
-		isSharedEngine = false
-	}
-
-    @Bean
-    fun kotlinScriptViewResolver() = ScriptTemplateViewResolver().apply {
-        setPrefix("templates/")
-        setSuffix(".kts")
-    }
-}
-----
-
-See the https://github.com/sdeleuze/kotlin-script-templating[kotlin-script-templating] example
-project for more details.
-
-
-
 [[kotlin-multiplatform-serialization]]
 == Kotlin multiplatform serialization
 
 {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.
-With Spring MVC and WebFlux, both Kotlin serialization and Jackson will be configured by default if they are in the classpath since
-Kotlin serialization is designed to serialize only Kotlin classes annotated with `@Serializable`.
-With Spring Messaging (RSocket), make sure that neither Jackson, GSON or JSONB are in the classpath if you want automatic configuration,
-if Jackson is needed configure `KotlinSerializationJsonMessageConverter` manually.
-
-
-
+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 dependencies
+and plugin. With Spring MVC and WebFlux, Kotlin serialization is configured by default if it is in the classpath and
+other variants like Jackson are not. If needed, configure the converters or codecs manually.

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

@@ -171,9 +171,9 @@ the parameters of a test class constructor are autowired from components in the
 
 If `@TestConstructor` is not present or meta-present on a test class, the default _test
 constructor autowire mode_ will be used. See the tip below for details on how to change
-the default mode. Note, however, that a local declaration of `@Autowired`,
-`@jakarta.inject.Inject`, or `@javax.inject.Inject` on a constructor takes precedence
-over both `@TestConstructor` and the default mode.
+the default mode. Note, however, that a local declaration of `@Autowired` or
+`@jakarta.inject.Inject` on a constructor takes precedence over both `@TestConstructor`
+and the default mode.
 
 .Changing the default test constructor autowire mode
 [TIP]

framework-docs/modules/ROOT/pages/testing/testcontext-framework/web-scoped-beans.adoc

@@ -96,9 +96,7 @@ Kotlin::
 The following code snippet is similar to the one we saw earlier for a request-scoped
 bean. However, this time, the `userService` bean has a dependency on a session-scoped
 `userPreferences` bean. Note that the `UserPreferences` bean is instantiated by using a
-SpEL expression that retrieves the theme from the current HTTP session. In our test, we
-need to configure a theme in the mock session managed by the TestContext framework. The
-following example shows how to do so:
+SpEL expression that retrieves an attribute from the current HTTP session.
 
 .Session-scoped bean configuration
 [source,xml,indent=0,subs="verbatim,quotes"]

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

@@ -804,8 +804,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	ClassPathResource index = new ClassPathResource("static/index.html");
-	List<String> extensions = List.of("js", "css", "ico", "png", "jpg", "gif");
-	RequestPredicate spaPredicate = path("/api/**").or(path("/error")).or(pathExtension(extensions::contains)).negate();
+	RequestPredicate spaPredicate = path("/api/**").or(path("/error")).negate();
 	RouterFunction<ServerResponse> redirectToIndex = route()
 		.resource(spaPredicate, index)
 		.build();
@@ -817,9 +816,7 @@ Kotlin::
 ----
 	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))
+		val spaPredicate = !(path("/api/**") or path("/error"))
 		resource(spaPredicate, index)
 	}
 ----

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

@@ -467,7 +467,7 @@ Java::
 ----
 	@GetMapping
 	FragmentsRendering handle() {
-		return FragmentsRendering.with("posts").fragment("comments").build();
+		return FragmentsRendering.fragment("posts").fragment("comments").build();
 	}
 ----
 
@@ -477,7 +477,7 @@ Kotlin::
 ----
 	@GetMapping
 	fun handle(): FragmentsRendering {
-		return FragmentsRendering.with("posts").fragment("comments").build()
+		return FragmentsRendering.fragment("posts").fragment("comments").build()
 	}
 ----
 ======

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

@@ -647,13 +647,12 @@ For https://www.webjars.org/documentation[WebJars], versioned URLs like
 `/webjars/jquery/1.2.0/jquery.min.js` are the recommended and most efficient way to use them.
 The related resource location is configured out of the box with Spring Boot (or can be configured
 manually via `ResourceHandlerRegistry`) and does not require to add the
-`org.webjars:webjars-locator-core` dependency.
+`org.webjars:webjars-locator-lite` dependency.
 
 Version-less URLs like `/webjars/jquery/jquery.min.js` are supported through the
 `WebJarsResourceResolver` which is automatically registered when the
-`org.webjars:webjars-locator-core` library is present on the classpath, at the cost of a
-classpath scanning that could slow down application startup. The resolver can re-write URLs to
-include the version of the jar and can also match against incoming URLs without versions
+`org.webjars:webjars-locator-lite` library is present on the classpath. The resolver can re-write
+URLs to include the version of the jar and can also match against incoming URLs without versions
 -- for example, from `/webjars/jquery/jquery.min.js` to `/webjars/jquery/1.2.0/jquery.min.js`.
 
 TIP: The Java configuration based on `ResourceHandlerRegistry` provides further options

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

@@ -783,7 +783,7 @@ Java::
 ----
     ClassPathResource index = new ClassPathResource("static/index.html");
 	List<String> extensions = List.of("js", "css", "ico", "png", "jpg", "gif");
-	RequestPredicate spaPredicate = path("/api/**").or(path("/error")).or(pathExtension(extensions::contains)).negate();
+	RequestPredicate spaPredicate = path("/api/**").or(path("/error")).negate();
 	RouterFunction<ServerResponse> redirectToIndex = route()
 		.resource(spaPredicate, index)
 		.build();
@@ -795,9 +795,7 @@ Kotlin::
 ----
     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))
+		val spaPredicate = !(path("/api/**") or path("/error"))
 		resource(spaPredicate, index)
 	}
 ----

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

@@ -48,7 +48,7 @@ Java::
 ----
 	@GetMapping
 	FragmentsRendering handle() {
-		return FragmentsRendering.with("posts").fragment("comments").build();
+		return FragmentsRendering.fragment("posts").fragment("comments").build();
 	}
 ----
 
@@ -58,7 +58,7 @@ Kotlin::
 ----
 	@GetMapping
 	fun handle(): FragmentsRendering {
-		return FragmentsRendering.with("posts").fragment("comments").build()
+		return FragmentsRendering.fragment("posts").fragment("comments").build()
 	}
 ----
 ======

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

@@ -118,12 +118,12 @@ See the sections on xref:web/webmvc-cors.adoc[CORS] and the xref:web/webmvc-cors
 [.small]#xref:web/webflux/reactive-spring.adoc#filters.url-handler[See equivalent in the Reactive stack]#
 
 In previous Spring Framework versions, Spring MVC could be configured to ignore trailing slashes in URL paths
-when mapping incoming requests on controller methods. This could be done by enabling the `setUseTrailingSlashMatch`
-option on the `PathMatchConfigurer`. This means that sending a "GET /home/" request would be handled by a controller
-method annotated with `@GetMapping("/home")`.
+when mapping incoming requests on controller methods. This means that sending a "GET /home/" request would be
+handled by a controller method annotated with `@GetMapping("/home")`.
 
-This option has been retired, but applications are still expected to handle such requests in a safe way.
-The `UrlHandlerFilter` Servlet filter has been designed for this purpose. It can be configured to:
+This option was deprecated in 6.0 and removed in 7.0, but applications are still expected to handle such
+requests in a safe way. The `UrlHandlerFilter` Servlet filter has been designed for this purpose.
+It can be configured to:
 
 * respond with an HTTP redirect status when receiving URLs with trailing slashes, sending browsers to the non-trailing slash URL variant.
 * wrap the request to act as if the request was sent without a trailing slash and continue the processing of the request.

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

@@ -54,6 +54,11 @@ You can customize XML mapping as needed through the use of JAXB or Jackson's pro
 When you need further control (for cases where custom XML serializers/deserializers need to be provided for specific types), you can inject a custom `XmlMapper` through the `ObjectMapper` property.
 By default, this converter supports `application/xml`. This requires the `com.fasterxml.jackson.dataformat:jackson-dataformat-xml` dependency.
 
+| `KotlinSerializationJsonHttpMessageConverter`
+| An `HttpMessageConverter` implementation that can read and write JSON using `kotlinx.serialization`.
+This converter is not configured by default, as this conflicts with Jackson.
+Developers must configure it as an additional converter ahead of the Jackson one.
+
 | `MappingJackson2CborHttpMessageConverter`
 | `com.fasterxml.jackson.dataformat:jackson-dataformat-cbor`
 

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

@@ -7,6 +7,10 @@ You can use the `@EnableWebMvc` annotation to enable MVC configuration with prog
 
 include-code::./WebConfiguration[tag=snippet,indent=0]
 
+WARNING: As of 7.0, support for the XML configuration namespace for Spring MVC has been deprecated.
+There are no plans yet for removing it completely but XML configuration will not be updated to follow
+the Java configuration model.
+
 NOTE: When using Spring Boot, you may want to use `@Configuration` classes of type `WebMvcConfigurer` but without `@EnableWebMvc` to keep Spring Boot MVC customizations. See more details in xref:web/webmvc/mvc-config/customize.adoc[the MVC Config API section] and in {spring-boot-docs-ref}/web/servlet.html#web.servlet.spring-mvc.auto-configuration[the dedicated Spring Boot documentation].
 
 The preceding example registers a number of Spring MVC

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

@@ -48,13 +48,12 @@ For https://www.webjars.org/documentation[WebJars], versioned URLs like
 `/webjars/jquery/1.2.0/jquery.min.js` are the recommended and most efficient way to use them.
 The related resource location is configured out of the box with Spring Boot (or can be configured
 manually via `ResourceHandlerRegistry`) and does not require to add the
-`org.webjars:webjars-locator-core` dependency.
+`org.webjars:webjars-locator-lite` dependency.
 
 Version-less URLs like `/webjars/jquery/jquery.min.js` are supported through the
 `WebJarsResourceResolver` which is automatically registered when the
-`org.webjars:webjars-locator-core` library is present on the classpath, at the cost of a
-classpath scanning that could slow down application startup. The resolver can re-write URLs to
-include the version of the jar and can also match against incoming URLs without versions
+`org.webjars:webjars-locator-lite` library is present on the classpath. The resolver can re-write
+URLs to include the version of the jar and can also match against incoming URLs without versions
 -- for example, from `/webjars/jquery/jquery.min.js` to `/webjars/jquery/1.2.0/jquery.min.js`.
 
 TIP: The Java configuration based on `ResourceHandlerRegistry` provides further options

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

@@ -30,8 +30,7 @@ and others) and is equivalent to `required=false`.
 
 | `jakarta.servlet.http.PushBuilder`
 | Servlet 4.0 push builder API for programmatic HTTP/2 resource pushes.
-  Note that, per the Servlet specification, the injected `PushBuilder` instance can be null if the client
-  does not support that HTTP/2 feature.
+  Note that this API has been deprecated as of Servlet 6.1.
 
 | `java.security.Principal`
 | Currently authenticated user -- possibly a specific `Principal` implementation class if known.

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

@@ -157,9 +157,7 @@ Kotlin::
 ----
 ======
 
-Note that you need to enable the use of matrix variables. In the MVC Java configuration,
-you need to set a `UrlPathHelper` with `removeSemicolonContent=false` through
-xref:web/webmvc/mvc-config/path-matching.adoc[Path Matching]. In the MVC XML namespace, you can set
+Note that you need to enable the use of matrix variables. In the MVC XML namespace, you can set
 `<mvc:annotation-driven enable-matrix-variables="true"/>`.
 
 

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

@@ -248,36 +248,6 @@ specific than other pattern that do not have double wildcards.
 For the full details, follow the above links to the pattern Comparators.
 
 
-[[mvc-ann-requestmapping-suffix-pattern-match]]
-== Suffix Match
-
-Starting in 5.3, by default Spring MVC no longer performs `.{asterisk}` suffix pattern
-matching where a controller mapped to `/person` is also implicitly mapped to
-`/person.{asterisk}`. As a consequence path extensions are no longer used to interpret
-the requested content type for the response -- for example, `/person.pdf`, `/person.xml`,
-and so on.
-
-Using file extensions in this way was necessary when browsers used to send `Accept` headers
-that were hard to interpret consistently. At present, that is no longer a necessity and
-using the `Accept` header should be the preferred choice.
-
-Over time, the use of file name extensions has proven problematic in a variety of ways.
-It can cause ambiguity when overlain with the use of URI variables, path parameters, and
-URI encoding. Reasoning about URL-based authorization
-and security (see next section for more details) also becomes more difficult.
-
-To completely disable the use of path extensions in versions prior to 5.3, set the following:
-
-* `useSuffixPatternMatching(false)`, see xref:web/webmvc/mvc-config/path-matching.adoc[PathMatchConfigurer]
-* `favorPathExtension(false)`, see xref:web/webmvc/mvc-config/content-negotiation.adoc[ContentNegotiationConfigurer]
-
-Having a way to request content types other than through the `"Accept"` header can still
-be useful, for example, when typing a URL in a browser. A safe alternative to path extensions is
-to use the query parameter strategy. If you must use file extensions, consider restricting
-them to a list of explicitly registered extensions through the `mediaTypes` property of
-xref:web/webmvc/mvc-config/content-negotiation.adoc[ContentNegotiationConfigurer].
-
-
 [[mvc-ann-requestmapping-rfd]]
 == Suffix Match and RFD
 

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

@@ -4,12 +4,8 @@
 
 [.small]#xref:web/webflux/http2.adoc[See equivalent in the Reactive stack]#
 
-Servlet 4 containers are required to support HTTP/2, and Spring Framework 5 is compatible
-with Servlet API 4. From a programming model perspective, there is nothing specific that
+Servlet 4 containers are required to support HTTP/2, and Spring Framework requires
+Servlet API 6.1. From a programming model perspective, there is nothing specific that
 applications need to do. However, there are considerations related to server configuration.
 For more details, see the
 {spring-framework-wiki}/HTTP-2-support[HTTP/2 wiki page].
-
-The Servlet API does expose one construct related to HTTP/2. You can use the
-`jakarta.servlet.http.PushBuilder` to proactively push resources to clients, and it
-is supported as a xref:web/webmvc/mvc-controller/ann-methods/arguments.adoc[method argument] to `@RequestMapping` methods.

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

@@ -11,8 +11,6 @@ The `DispatcherServlet` processes requests as follows:
 * The locale resolver is bound to the request to let elements in the process
   resolve the locale to use when processing the request (rendering the view, preparing
   data, and so on). If you do not need locale resolving, you do not need the locale resolver.
-* The theme resolver is bound to the request to let elements such as views determine
-  which theme to use. If you do not use themes, you can ignore it.
 * If you specify a multipart file resolver, the request is inspected for multiparts. If
   multiparts are found, the request is wrapped in a `MultipartHttpServletRequest` for
   further processing by other elements in the process. See xref:web/webmvc/mvc-servlet/multipart.adoc[Multipart Resolver] for further

framework-docs/modules/ROOT/pages/web/webmvc/mvc-servlet/special-bean-types.adoc

@@ -43,10 +43,6 @@ The following table lists the special beans detected by the `DispatcherServlet`:
 | Resolve the `Locale` a client is using and possibly their time zone, in order to be able
   to offer internationalized views. See xref:web/webmvc/mvc-servlet/localeresolver.adoc[Locale].
 
-| xref:web/webmvc/mvc-servlet/themeresolver.adoc[`ThemeResolver`]
-| Resolve themes your web application can use -- for example, to offer personalized layouts.
-  See xref:web/webmvc/mvc-servlet/themeresolver.adoc[Themes].
-
 | xref:web/webmvc/mvc-servlet/multipart.adoc[`MultipartResolver`]
 | Abstraction for parsing a multi-part request (for example, browser form file upload) with
   the help of some multipart parsing library. See xref:web/webmvc/mvc-servlet/multipart.adoc[Multipart Resolver].

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

@@ -1,92 +0,0 @@
-[[mvc-themeresolver]]
-= Themes
-
-You can apply Spring Web MVC framework themes to set the overall look-and-feel of your
-application, thereby enhancing user experience. A theme is a collection of static
-resources, typically style sheets and images, that affect the visual style of the
-application.
-
-WARNING: as of 6.0 support for themes has been deprecated theme in favor of using CSS,
-and without any special support on the server side.
-
-
-[[mvc-themeresolver-defining]]
-== Defining a theme
-
-To use themes in your web application, you must set up an implementation of the
-`org.springframework.ui.context.ThemeSource` interface. The `WebApplicationContext`
-interface extends `ThemeSource` but delegates its responsibilities to a dedicated
-implementation. By default, the delegate is an
-`org.springframework.ui.context.support.ResourceBundleThemeSource` implementation that
-loads properties files from the root of the classpath. To use a custom `ThemeSource`
-implementation or to configure the base name prefix of the `ResourceBundleThemeSource`,
-you can register a bean in the application context with the reserved name, `themeSource`.
-The web application context automatically detects a bean with that name and uses it.
-
-When you use the `ResourceBundleThemeSource`, a theme is defined in a simple properties
-file. The properties file lists the resources that make up the theme, as the following example shows:
-
-[literal,subs="verbatim,quotes"]
-----
-styleSheet=/themes/cool/style.css
-background=/themes/cool/img/coolBg.jpg
-----
-
-The keys of the properties are the names that refer to the themed elements from view
-code. For a JSP, you typically do this using the `spring:theme` custom tag, which is
-very similar to the `spring:message` tag. The following JSP fragment uses the theme
-defined in the previous example to customize the look and feel:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
-	<html>
-		<head>
-			<link rel="stylesheet" href="<spring:theme code='styleSheet'/>" type="text/css"/>
-		</head>
-		<body style="background=<spring:theme code='background'/>">
-			...
-		</body>
-	</html>
-----
-
-By default, the `ResourceBundleThemeSource` uses an empty base name prefix. As a result,
-the properties files are loaded from the root of the classpath. Thus, you would put the
-`cool.properties` theme definition in a directory at the root of the classpath (for
-example, in `/WEB-INF/classes`). The `ResourceBundleThemeSource` uses the standard Java
-resource bundle loading mechanism, allowing for full internationalization of themes. For
-example, we could have a `/WEB-INF/classes/cool_nl.properties` that references a special
-background image with Dutch text on it.
-
-
-[[mvc-themeresolver-resolving]]
-== Resolving Themes
-
-After you define themes, as described in the xref:web/webmvc/mvc-servlet/themeresolver.adoc#mvc-themeresolver-defining[preceding section],
-you decide which theme to use. The `DispatcherServlet` looks for a bean named `themeResolver`
-to find out which `ThemeResolver` implementation to use. A theme resolver works in much the same
-way as a `LocaleResolver`. It detects the theme to use for a particular request and can also
-alter the request's theme. The following table describes the theme resolvers provided by Spring:
-
-[[mvc-theme-resolver-impls-tbl]]
-.ThemeResolver implementations
-[cols="1,4"]
-|===
-| Class | Description
-
-| `FixedThemeResolver`
-| Selects a fixed theme, set by using the `defaultThemeName` property.
-
-| `SessionThemeResolver`
-| The theme is maintained in the user's HTTP session. It needs to be set only once for
-  each session but is not persisted between sessions.
-
-| `CookieThemeResolver`
-| The selected theme is stored in a cookie on the client.
-|===
-
-Spring also provides a `ThemeChangeInterceptor` that lets theme changes on every
-request with a simple request parameter.
-
-
-

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

@@ -85,10 +85,7 @@ for all HTTP processing -- including WebSocket handshake and all other HTTP
 requests -- such as Spring MVC's `DispatcherServlet`.
 
 This is a significant limitation of JSR-356 that Spring's WebSocket support addresses with
-server-specific `RequestUpgradeStrategy` implementations even when running in a JSR-356 runtime.
-Such strategies currently exist for Tomcat, Jetty, GlassFish, WebLogic, WebSphere, and Undertow
-(and WildFly). As of Jakarta WebSocket 2.1, a standard request upgrade strategy is available
-which Spring chooses on Jakarta EE 10 based web containers such as Tomcat 10.1 and Jetty 12.
+a standard `RequestUpgradeStrategy` implementation when running in a WebSocket API 2.1+ runtime.
 
 A secondary consideration is that Servlet containers with JSR-356 support are expected
 to perform a `ServletContainerInitializer` (SCI) scan that can slow down application

framework-docs/src/main/java/org/springframework/docs/core/aot/hints/testing/SampleReflectionRuntimeHintsTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2022 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,7 +24,6 @@ import org.springframework.aot.hint.ExecutableMode;
 import org.springframework.aot.hint.RuntimeHints;
 import org.springframework.aot.test.agent.EnabledIfRuntimeHintsAgent;
 import org.springframework.aot.test.agent.RuntimeHintsInvocations;
-import org.springframework.aot.test.agent.RuntimeHintsRecorder;
 import org.springframework.core.SpringVersion;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -33,6 +32,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 // method is only enabled if the RuntimeHintsAgent is loaded on the current JVM.
 // It also tags tests with the "RuntimeHints" JUnit tag.
 @EnabledIfRuntimeHintsAgent
+@SuppressWarnings("removal")
 class SampleReflectionRuntimeHintsTests {
 
 	@Test
@@ -43,7 +43,7 @@ class SampleReflectionRuntimeHintsTests {
 				typeHint.withMethod("getVersion", List.of(), ExecutableMode.INVOKE));
 
 		// Invoke the relevant piece of code we want to test within a recording lambda
-		RuntimeHintsInvocations invocations = RuntimeHintsRecorder.record(() -> {
+		RuntimeHintsInvocations invocations = org.springframework.aot.test.agent.RuntimeHintsRecorder.record(() -> {
 			SampleReflection sample = new SampleReflection();
 			sample.performReflection();
 		});

framework-docs/src/main/kotlin/org/springframework/docs/core/beans/dependencies/beansfactorylazyinit/AnotherBean.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,11 +14,7 @@
  * limitations under the License.
  */
 
-package example.indexed;
+package org.springframework.docs.core.beans.dependencies.beansfactorylazyinit
 
-/**
- * @author Sam Brannen
- */
-@javax.annotation.ManagedBean
-public class IndexedJavaxManagedBeanComponent {
-}
+class AnotherBean {
+}

framework-docs/src/main/kotlin/org/springframework/docs/core/beans/dependencies/beansfactorylazyinit/ExpensiveToCreateBean.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2022 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,11 +14,7 @@
  * limitations under the License.
  */
 
-package example.indexed;
+package org.springframework.docs.core.beans.dependencies.beansfactorylazyinit
 
-/**
- * @author Sam Brannen
- */
-@jakarta.annotation.ManagedBean
-public class IndexedJakartaManagedBeanComponent {
-}
+class ExpensiveToCreateBean {
+}

framework-docs/src/main/kotlin/org/springframework/docs/core/expressions/expressionsbeandef/CustomerPreferenceDao.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,11 +14,7 @@
  * limitations under the License.
  */
 
-package example.scannable;
+package org.springframework.docs.core.expressions.expressionsbeandef
 
-/**
- * @author Sam Brannen
- */
-@javax.inject.Named("myJavaxNamedComponent")
-public class JavaxNamedComponent {
-}
+class CustomerPreferenceDao {
+}

framework-docs/src/main/kotlin/org/springframework/docs/core/expressions/expressionsbeandef/MovieFinder.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,11 +14,8 @@
  * limitations under the License.
  */
 
-package example.indexed;
 
-/**
- * @author Sam Brannen
- */
-@javax.inject.Named("myIndexedJavaxNamedComponent")
-public class IndexedJavaxNamedComponent {
-}
+package org.springframework.docs.core.expressions.expressionsbeandef
+
+class MovieFinder {
+}

framework-docs/src/main/kotlin/org/springframework/docs/dataaccess/jdbc/jdbccomplextypes/TestItem.kt

@@ -14,16 +14,8 @@
  * limitations under the License.
  */
 
-package org.springframework.web.servlet.view;
+package org.springframework.docs.dataaccess.jdbc.jdbccomplextypes
 
-/**
- * @author Rod Johnson
- */
-class ResourceBundleViewResolverNoCacheTests extends ResourceBundleViewResolverTests {
+import java.util.Date
 
-	@Override
-	protected boolean getCache() {
-		return false;
-	}
-
-}
+data class TestItem(val id: Long, val description: String, val expirationDate: Date)

framework-docs/src/main/kotlin/org/springframework/docs/dataaccess/jdbc/jdbccomplextypes/TestItemStoredProcedure.kt

@@ -31,11 +31,11 @@ class TestItemStoredProcedure(dataSource: DataSource) : StoredProcedure(dataSour
 				cs: CallableStatement, colIndx: Int, _: Int, _: String? ->
 				val struct = cs.getObject(colIndx) as Struct
 				val attr = struct.attributes
-				val item = TestItem()
-				item.id = (attr[0] as Number).toLong()
-				item.description = attr[1] as String
-				item.expirationDate = attr[2] as Date
-				item
+				TestItem(
+					(attr[0] as Number).toLong(),
+					attr[1] as String,
+					attr[2] as Date
+				)
 			})
 		// ...
 	}

framework-docs/src/main/kotlin/org/springframework/docs/dataaccess/jdbc/jdbcjdbctemplateidioms/CorporateEventDao.kt

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

framework-docs/src/main/kotlin/org/springframework/docs/integration/cache/cachestoreconfigurationcaffeine/CustomCacheConfiguration.kt

@@ -28,9 +28,7 @@ class CustomCacheConfiguration {
 	// tag::snippet[]
 	@Bean
 	fun cacheManager(): CacheManager {
-		return CaffeineCacheManager().apply {
-			cacheNames = listOf("default", "books")
-		}
+		return CaffeineCacheManager("default", "books")
 	}
 	// end::snippet[]
 }

framework-docs/src/main/kotlin/org/springframework/docs/integration/jmx/jmxexporting/IJmxTestBean.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
-package example.scannable;
+package org.springframework.docs.integration.jmx.jmxexporting
 
-/**
- * @author Sam Brannen
- */
-@jakarta.annotation.ManagedBean("myJakartaManagedBeanComponent")
-public class JakartaManagedBeanComponent {
-}
+interface IJmxTestBean {
+
+	var name: String
+	var age: Int
+	fun add(x: Int, y: Int): Int
+	fun dontExposeMe()
+}

framework-docs/src/main/kotlin/org/springframework/docs/integration/jmx/jmxexporting/JmxTestBean.kt

@@ -19,24 +19,8 @@ package org.springframework.docs.integration.jmx.jmxexporting
 // tag::snippet[]
 class JmxTestBean : IJmxTestBean {
 
-	private lateinit var name: String
-	private var age = 0
-
-	override fun getAge(): Int {
-		return age
-	}
-
-	override fun setAge(age: Int) {
-		this.age = age
-	}
-
-	override fun setName(name: String) {
-		this.name = name
-	}
-
-	override fun getName(): String {
-		return name
-	}
+	override lateinit var name: String
+	override var age = 0
 
 	override fun add(x: Int, y: Int): Int {
 		return x + y

framework-docs/src/main/kotlin/org/springframework/docs/integration/mailusagesimple/Customer.kt

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

framework-docs/src/main/kotlin/org/springframework/docs/integration/mailusagesimple/Order.kt

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

framework-docs/src/main/kotlin/org/springframework/docs/testing/mockmvc/assertj/mockmvctestersetup/AccountController.kt

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

framework-docs/src/main/kotlin/org/springframework/docs/testing/mockmvc/assertj/mockmvctestersetup/ApplicationWebConfiguration.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2002-2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.docs.testing.mockmvc.assertj.mockmvctestersetup
+
+import org.springframework.context.annotation.Configuration
+import org.springframework.web.servlet.config.annotation.EnableWebMvc
+
+@Configuration(proxyBeanMethods = false)
+@EnableWebMvc
+class ApplicationWebConfiguration {
+}

framework-docs/src/main/kotlin/org/springframework/docs/web/webmvc/mvcconfig/mvcconfiginterceptors/WebConfiguration.kt

@@ -14,14 +14,13 @@
  * limitations under the License.
  */
 
-@file:Suppress("DEPRECATION")
 package org.springframework.docs.web.webmvc.mvcconfig.mvcconfiginterceptors
 
 import org.springframework.context.annotation.Configuration
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
+import org.springframework.web.servlet.handler.UserRoleAuthorizationInterceptor
 import org.springframework.web.servlet.i18n.LocaleChangeInterceptor
-import org.springframework.web.servlet.theme.ThemeChangeInterceptor
 
 // tag::snippet[]
 @Configuration
@@ -29,7 +28,7 @@ class WebConfiguration : WebMvcConfigurer {
 
 	override fun addInterceptors(registry: InterceptorRegistry) {
 		registry.addInterceptor(LocaleChangeInterceptor())
-		registry.addInterceptor(ThemeChangeInterceptor()).addPathPatterns("/**").excludePathPatterns("/admin/**")
+		registry.addInterceptor(UserRoleAuthorizationInterceptor()).addPathPatterns("/**").excludePathPatterns("/admin/**")
 	}
 }
 // end::snippet[]

framework-docs/src/main/kotlin/org/springframework/docs/web/webmvc/mvcconfig/mvcconfigvalidation/FooValidator.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2002-2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.docs.web.webmvc.mvcconfig.mvcconfigvalidation
+
+import org.springframework.validation.Errors
+import org.springframework.validation.Validator
+
+class FooValidator : Validator {
+	override fun supports(clazz: Class<*>) = false
+
+	override fun validate(target: Any, errors: Errors) {
+	}
+}

framework-docs/src/main/kotlin/org/springframework/docs/web/websocket/websocketserverruntimeconfiguration/MyEchoHandler.kt

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

framework-docs/src/main/resources/org/springframework/docs/web/webmvc/mvcconfig/mvcconfiginterceptors/WebConfiguration.xml

@@ -14,7 +14,9 @@
 		<mvc:interceptor>
 			<mvc:mapping path="/**"/>
 			<mvc:exclude-mapping path="/admin/**"/>
-			<bean class="org.springframework.web.servlet.theme.ThemeChangeInterceptor"/>
+			<bean class="org.springframework.web.servlet.handler.UserRoleAuthorizationInterceptor">
+				<property name="authorizedRoles" value="ROLE_USER"/>
+			</bean>
 		</mvc:interceptor>
 	</mvc:interceptors>
 	<!-- end::snippet[] -->

framework-platform/framework-platform.gradle

@@ -10,16 +10,15 @@ dependencies {
 	api(platform("com.fasterxml.jackson:jackson-bom:2.18.3"))
 	api(platform("io.micrometer:micrometer-bom:1.14.5"))
 	api(platform("io.netty:netty-bom:4.1.119.Final"))
-	api(platform("io.netty:netty5-bom:5.0.0.Alpha5"))
-	api(platform("io.projectreactor:reactor-bom:2024.0.4"))
+	api(platform("io.projectreactor:reactor-bom:2025.0.0-M1"))
 	api(platform("io.rsocket:rsocket-bom:1.1.5"))
 	api(platform("org.apache.groovy:groovy-bom:4.0.26"))
-	api(platform("org.apache.logging.log4j:log4j-bom:2.21.1"))
+	api(platform("org.apache.logging.log4j:log4j-bom:3.0.0-beta3"))
 	api(platform("org.assertj:assertj-bom:3.27.3"))
-	api(platform("org.eclipse.jetty:jetty-bom:12.0.17"))
-	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.17"))
-	api(platform("org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.8.1"))
-	api(platform("org.jetbrains.kotlinx:kotlinx-serialization-bom:1.6.3"))
+	api(platform("org.eclipse.jetty:jetty-bom:12.1.0.alpha1"))
+	api(platform("org.eclipse.jetty.ee11:jetty-ee11-bom:12.1.0.alpha1"))
+	api(platform("org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.10.1"))
+	api(platform("org.jetbrains.kotlinx:kotlinx-serialization-bom:1.8.0"))
 	api(platform("org.junit:junit-bom:5.12.0"))
 	api(platform("org.mockito:mockito-bom:5.16.0"))
 
@@ -34,22 +33,21 @@ dependencies {
 		api("com.google.protobuf:protobuf-java-util:4.30.0")
 		api("com.h2database:h2:2.3.232")
 		api("com.jayway.jsonpath:json-path:2.9.0")
+		api("com.networknt:json-schema-validator:1.5.3")
 		api("com.oracle.database.jdbc:ojdbc11:21.9.0.0")
 		api("com.rometools:rome:1.19.0")
 		api("com.squareup.okhttp3:mockwebserver:3.14.9")
-		api("com.squareup.okhttp3:okhttp:3.14.9")
 		api("com.sun.activation:jakarta.activation:2.0.1")
-		api("com.sun.mail:jakarta.mail:2.0.1")
 		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.2.0")
 		api("com.thoughtworks.xstream:xstream:1.4.21")
 		api("commons-io:commons-io:2.15.0")
+		api("commons-logging:commons-logging:1.3.4")
 		api("de.bechte.junit:junit-hierarchicalcontextrunner:4.12.2")
 		api("io.micrometer:context-propagation:1.1.1")
 		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")
 		api("io.r2dbc:r2dbc-h2:1.0.0.RELEASE")
 		api("io.r2dbc:r2dbc-spi-test:1.0.0.RELEASE")
@@ -60,32 +58,31 @@ dependencies {
 		api("io.undertow:undertow-servlet:2.3.18.Final")
 		api("io.undertow:undertow-websockets-jsr:2.3.18.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")
+		api("jakarta.activation:jakarta.activation-api:2.1.3")
+		api("jakarta.annotation:jakarta.annotation-api:3.0.0")
+		api("jakarta.validation:jakarta.validation-api:3.1.0")
 		api("jakarta.ejb:jakarta.ejb-api:4.0.1")
-		api("jakarta.el:jakarta.el-api:4.0.0")
-		api("jakarta.enterprise.concurrent:jakarta.enterprise.concurrent-api:2.0.0")
-		api("jakarta.faces:jakarta.faces-api:3.0.0")
+		api("jakarta.el:jakarta.el-api:6.0.1")
+		api("jakarta.enterprise.concurrent:jakarta.enterprise.concurrent-api:3.1.1")
+		api("jakarta.faces:jakarta.faces-api:4.1.2")
 		api("jakarta.inject:jakarta.inject-api:2.0.1")
 		api("jakarta.inject:jakarta.inject-tck:2.0.1")
-		api("jakarta.interceptor:jakarta.interceptor-api:2.0.0")
-		api("jakarta.jms:jakarta.jms-api:3.0.0")
-		api("jakarta.json.bind:jakarta.json.bind-api:2.0.0")
-		api("jakarta.json:jakarta.json-api:2.0.1")
-		api("jakarta.mail:jakarta.mail-api:2.0.1")
-		api("jakarta.persistence:jakarta.persistence-api:3.0.0")
-		api("jakarta.resource:jakarta.resource-api:2.0.0")
-		api("jakarta.servlet.jsp.jstl:jakarta.servlet.jsp.jstl-api:3.0.0")
-		api("jakarta.servlet.jsp:jakarta.servlet.jsp-api:3.1.1")
-		api("jakarta.servlet:jakarta.servlet-api:6.0.0")
+		api("jakarta.interceptor:jakarta.interceptor-api:2.2.0")
+		api("jakarta.jms:jakarta.jms-api:3.1.0")
+		api("jakarta.json.bind:jakarta.json.bind-api:3.0.1")
+		api("jakarta.json:jakarta.json-api:2.1.3")
+		api("jakarta.mail:jakarta.mail-api:2.1.3")
+		api("jakarta.persistence:jakarta.persistence-api:3.2.0")
+		api("jakarta.resource:jakarta.resource-api:2.1.0")
+		api("jakarta.servlet.jsp.jstl:jakarta.servlet.jsp.jstl-api:3.0.2")
+		api("jakarta.servlet.jsp:jakarta.servlet.jsp-api:4.0.0")
+		api("jakarta.servlet:jakarta.servlet-api:6.1.0")
 		api("jakarta.transaction:jakarta.transaction-api:2.0.1")
-		api("jakarta.validation:jakarta.validation-api:3.0.2")
-		api("jakarta.websocket:jakarta.websocket-api:2.1.0")
-		api("jakarta.websocket:jakarta.websocket-client-api:2.1.0")
+		api("jakarta.validation:jakarta.validation-api:3.1.0")
+		api("jakarta.websocket:jakarta.websocket-api:2.2.0")
+		api("jakarta.websocket:jakarta.websocket-client-api:2.2.0")
 		api("jakarta.xml.bind:jakarta.xml.bind-api:3.0.1")
-		api("javax.annotation:javax.annotation-api:1.3.2")
 		api("javax.cache:cache-api:1.1.1")
-		api("javax.inject:javax.inject:1")
 		api("javax.money:money-api:1.1")
 		api("jaxen:jaxen:1.2.0")
 		api("junit:junit:4.13.2")
@@ -103,10 +100,10 @@ dependencies {
 		api("org.apache.httpcomponents.client5:httpclient5:5.4.2")
 		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.3.3")
 		api("org.apache.poi:poi-ooxml:5.2.5")
-		api("org.apache.tomcat.embed:tomcat-embed-core:10.1.28")
-		api("org.apache.tomcat.embed:tomcat-embed-websocket:10.1.28")
-		api("org.apache.tomcat:tomcat-util:10.1.28")
-		api("org.apache.tomcat:tomcat-websocket:10.1.28")
+		api("org.apache.tomcat.embed:tomcat-embed-core:11.0.1")
+		api("org.apache.tomcat.embed:tomcat-embed-websocket:11.0.1")
+		api("org.apache.tomcat:tomcat-util:11.0.1")
+		api("org.apache.tomcat:tomcat-websocket:11.0.1")
 		api("org.aspectj:aspectjrt:1.9.22.1")
 		api("org.aspectj:aspectjtools:1.9.22.1")
 		api("org.aspectj:aspectjweaver:1.9.22.1")
@@ -116,35 +113,35 @@ dependencies {
 		api("org.crac:crac:1.4.0")
 		api("org.dom4j:dom4j:2.1.4")
 		api("org.easymock:easymock:5.5.0")
+		api("org.eclipse.angus:angus-mail:2.0.3")
 		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.9")
-		api("org.eclipse.persistence:org.eclipse.persistence.jpa:3.0.4")
-		api("org.eclipse:yasson:2.0.4")
+		api("org.eclipse.persistence:org.eclipse.persistence.jpa:5.0.0-B04")
+		api("org.eclipse:yasson:3.0.4")
 		api("org.ehcache:ehcache:3.10.8")
 		api("org.ehcache:jcache:1.0.1")
 		api("org.freemarker:freemarker:2.3.34")
 		api("org.glassfish.external:opendmk_jmxremote_optional_jar:1.0-b01-ea")
 		api("org.glassfish:jakarta.el:4.0.2")
-		api("org.glassfish.tyrus:tyrus-container-servlet:2.1.3")
 		api("org.graalvm.sdk:graal-sdk:22.3.1")
-		api("org.hamcrest:hamcrest:2.2")
-		api("org.hibernate:hibernate-core-jakarta:5.6.15.Final")
-		api("org.hibernate:hibernate-validator:7.0.5.Final")
+		api("org.hamcrest:hamcrest:3.0")
+		api("org.hibernate.orm:hibernate-core:7.0.0.Beta4")
+		api("org.hibernate.validator:hibernate-validator:9.0.0.CR1")
 		api("org.hsqldb:hsqldb:2.7.4")
 		api("org.htmlunit:htmlunit:4.10.0")
 		api("org.javamoney:moneta:1.4.4")
 		api("org.jruby:jruby:9.4.12.0")
+		api("org.jspecify:jspecify:1.0.0")
 		api("org.junit.support:testng-engine:1.0.5")
 		api("org.mozilla:rhino:1.7.15")
 		api("org.ogce:xpp3:1.1.6")
 		api("org.python:jython-standalone:2.7.4")
 		api("org.quartz-scheduler:quartz:2.3.2")
+		api("org.reactivestreams:reactive-streams:1.0.4")
 		api("org.seleniumhq.selenium:htmlunit3-driver:4.29.0")
 		api("org.seleniumhq.selenium:selenium-java:4.29.0")
-		api("org.skyscreamer:jsonassert:1.5.3")
-		api("org.slf4j:slf4j-api:2.0.17")
+		api("org.skyscreamer:jsonassert:2.0-rc1")
 		api("org.testng:testng:7.11.0")
 		api("org.webjars:underscorejs:1.8.3")
-		api("org.webjars:webjars-locator-core:0.59")
 		api("org.webjars:webjars-locator-lite:1.1.0")
 		api("org.xmlunit:xmlunit-assertj:2.10.0")
 		api("org.xmlunit:xmlunit-matchers:2.10.0")

gradle.properties

@@ -1,10 +1,10 @@
-version=6.2.5-SNAPSHOT
+version=7.0.0-M3
 
 org.gradle.caching=true
 org.gradle.jvmargs=-Xmx2048m
 org.gradle.parallel=true
 
-kotlinVersion=1.9.25
+kotlinVersion=2.1.10
 
 kotlin.jvm.target.validation.mode=ignore
 kotlin.stdlib.default.dependency=false

gradle/spring-module.gradle

@@ -13,8 +13,8 @@ dependencies {
 	jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.37'
 	jmh 'org.openjdk.jmh:jmh-generator-bytecode:1.37'
 	jmh 'net.sf.jopt-simple:jopt-simple'
-	errorprone 'com.uber.nullaway:nullaway:0.10.26'
-	errorprone 'com.google.errorprone:error_prone_core:2.9.0'
+	errorprone 'com.uber.nullaway:nullaway:0.12.4'
+	errorprone 'com.google.errorprone:error_prone_core:2.36.0'
 }
 
 pluginManager.withPlugin("kotlin") {
@@ -76,9 +76,9 @@ javadoc {
 	options.header = project.name
 	options.use = true
 	options.links(project.ext.javadocLinks)
-	// Check for syntax during linting. 'none' doesn't seem to work in suppressing
-	// all linting warnings all the time (see/link references most notably).
-	options.addStringOption("Xdoclint:syntax", "-quiet")
+	options.setOutputLevel(JavadocOutputLevel.QUIET)
+	// Check for syntax during linting.
+	options.addBooleanOption("Xdoclint:syntax", true)
 
 	// Suppress warnings due to cross-module @see and @link references.
 	// Note that global 'api' task does display all warnings, and
@@ -116,11 +116,9 @@ components.java.withVariantsFromConfiguration(configurations.testFixturesRuntime
 tasks.withType(JavaCompile).configureEach {
     options.errorprone {
     	disableAllChecks = true
-        option("NullAway:CustomContractAnnotations", "org.springframework.lang.Contract")
-        option("NullAway:AnnotatedPackages", "org.springframework")
-        option("NullAway:UnannotatedSubPackages", "org.springframework.instrument,org.springframework.context.index," +
-				"org.springframework.asm,org.springframework.cglib,org.springframework.objenesis," +
-				"org.springframework.javapoet,org.springframework.aot.nativex.substitution,org.springframework.aot.nativex.feature")
+		option("NullAway:OnlyNullMarked", "true")
+		option("NullAway:CustomContractAnnotations", "org.springframework.lang.Contract")
+		option("NullAway:JSpecifyMode", "true")
     }
 }
 tasks.compileJava {

gradle/toolchains.gradle

@@ -1,99 +0,0 @@
-/**
- * Apply the JVM Toolchain conventions
- * See https://docs.gradle.org/current/userguide/toolchains.html
- *
- * One can choose the toolchain to use for compiling and running the TEST sources.
- * These options apply to Java, Kotlin and Groovy test sources when available.
- * {@code "./gradlew check -PtestToolchain=22"} will use a JDK22
- * toolchain for compiling and running the test SourceSet.
- *
- * By default, the main build will fall back to using the a JDK 17
- * toolchain (and 17 language level) for all main sourceSets.
- * See {@link org.springframework.build.JavaConventions}.
- *
- * Gradle will automatically detect JDK distributions in well-known locations.
- * The following command will list the detected JDKs on the host.
- * {@code
- * $ ./gradlew -q javaToolchains
- * }
- *
- * We can also configure ENV variables and let Gradle know about them:
- * {@code
- * $ echo JDK17
- * /opt/openjdk/java17
- * $ echo JDK22
- * /opt/openjdk/java22
- * $ ./gradlew -Porg.gradle.java.installations.fromEnv=JDK17,JDK22 check
- * }
- *
- * @author Brian Clozel
- * @author Sam Brannen
- */
-
-def testToolchainConfigured() {
-	return project.hasProperty('testToolchain') && project.testToolchain
-}
-
-def testToolchainLanguageVersion() {
-	if (testToolchainConfigured()) {
-		return JavaLanguageVersion.of(project.testToolchain.toString())
-	}
-	return JavaLanguageVersion.of(17)
-}
-
-plugins.withType(JavaPlugin).configureEach {
-	// Configure a specific Java Toolchain for compiling and running tests if the 'testToolchain' property is defined
-	if (testToolchainConfigured()) {
-		def testLanguageVersion = testToolchainLanguageVersion()
-		tasks.withType(JavaCompile).matching { it.name.contains("Test") }.configureEach {
-			javaCompiler = javaToolchains.compilerFor {
-				languageVersion = testLanguageVersion
-			}
-		}
-		tasks.withType(Test).configureEach{
-			javaLauncher = javaToolchains.launcherFor {
-				languageVersion = testLanguageVersion
-			}
-			// Enable Java experimental support in Bytebuddy
-			// Bytebuddy 1.15.4 supports JDK <= 24
-			// see https://github.com/raphw/byte-buddy/blob/master/release-notes.md
-			if (testLanguageVersion.compareTo(JavaLanguageVersion.of(24)) > 0 ) {
-				jvmArgs("-Dnet.bytebuddy.experimental=true")
-			}
-		}
-	}
-}
-
-// Configure the JMH plugin to use the toolchain for generating and running JMH bytecode
-pluginManager.withPlugin("me.champeau.jmh") {
-	if (testToolchainConfigured()) {
-		tasks.matching { it.name.contains('jmh') && it.hasProperty('javaLauncher') }.configureEach {
-			javaLauncher.set(javaToolchains.launcherFor {
-				languageVersion.set(testToolchainLanguageVersion())
-			})
-		}
-		tasks.withType(JavaCompile).matching { it.name.contains("Jmh") }.configureEach {
-			javaCompiler = javaToolchains.compilerFor {
-				languageVersion = testToolchainLanguageVersion()
-			}
-		}
-	}
-}
-
-// Store resolved Toolchain JVM information as custom values in the build scan.
-rootProject.ext {
-	resolvedMainToolchain = false
-	resolvedTestToolchain = false
-}
-gradle.taskGraph.afterTask { Task task, TaskState state ->
-	if (!resolvedMainToolchain && task instanceof JavaCompile && task.javaCompiler.isPresent()) {
-		def metadata = task.javaCompiler.get().metadata
-		task.project.develocity.buildScan.value('Main toolchain', "$metadata.vendor $metadata.languageVersion ($metadata.installationPath)")
-		resolvedMainToolchain = true
-	}
-	if (testToolchainConfigured() && !resolvedTestToolchain && task instanceof Test && task.javaLauncher.isPresent()) {
-		def metadata = task.javaLauncher.get().metadata
-		task.project.develocity.buildScan.value('Test toolchain', "$metadata.vendor $metadata.languageVersion ($metadata.installationPath)")
-		resolvedTestToolchain = true
-	}
-}

integration-tests/integration-tests.gradle

@@ -26,7 +26,7 @@ dependencies {
 	testImplementation("jakarta.servlet:jakarta.servlet-api")
 	testImplementation("org.aspectj:aspectjweaver")
 	testImplementation("org.hsqldb:hsqldb")
-	testImplementation("org.hibernate:hibernate-core-jakarta")
+	testImplementation("org.hibernate.orm:hibernate-core")
 	testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")
 }
 

integration-tests/src/test/java/org/springframework/aop/framework/autoproxy/AdvisorAutoProxyCreatorIntegrationTests.java

@@ -20,6 +20,7 @@ import java.lang.reflect.Method;
 import java.util.List;
 
 import jakarta.servlet.ServletException;
+import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.aop.support.AopUtils;
@@ -31,7 +32,6 @@ import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.testfixture.beans.ITestBean;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
-import org.springframework.lang.Nullable;
 import org.springframework.transaction.NoTransactionException;
 import org.springframework.transaction.interceptor.TransactionInterceptor;
 import org.springframework.transaction.testfixture.CallCountingTransactionManager;

integration-tests/src/test/java/org/springframework/aot/test/ReflectionInvocationsTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2022 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,24 +18,23 @@ package org.springframework.aot.test;
 
 import org.junit.jupiter.api.Test;
 
-import org.springframework.aot.hint.MemberCategory;
 import org.springframework.aot.hint.RuntimeHints;
 import org.springframework.aot.test.agent.EnabledIfRuntimeHintsAgent;
 import org.springframework.aot.test.agent.RuntimeHintsInvocations;
-import org.springframework.aot.test.agent.RuntimeHintsRecorder;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 
 @EnabledIfRuntimeHintsAgent
+@SuppressWarnings("removal")
 class ReflectionInvocationsTests {
 
 	@Test
 	void sampleTest() {
 		RuntimeHints hints = new RuntimeHints();
-		hints.reflection().registerType(String.class, MemberCategory.INTROSPECT_PUBLIC_METHODS);
+		hints.reflection().registerType(String.class);
 
-		RuntimeHintsInvocations invocations = RuntimeHintsRecorder.record(() -> {
+		RuntimeHintsInvocations invocations = org.springframework.aot.test.agent.RuntimeHintsRecorder.record(() -> {
 			SampleReflection sample = new SampleReflection();
 			sample.sample(); // does Method[] methods = String.class.getMethods();
 		});
@@ -45,9 +44,9 @@ class ReflectionInvocationsTests {
 	@Test
 	void multipleCallsTest() {
 		RuntimeHints hints = new RuntimeHints();
-		hints.reflection().registerType(String.class, MemberCategory.INTROSPECT_PUBLIC_METHODS);
-		hints.reflection().registerType(Integer.class,MemberCategory.INTROSPECT_PUBLIC_METHODS);
-		RuntimeHintsInvocations invocations = RuntimeHintsRecorder.record(() -> {
+		hints.reflection().registerType(String.class);
+		hints.reflection().registerType(Integer.class);
+		RuntimeHintsInvocations invocations = org.springframework.aot.test.agent.RuntimeHintsRecorder.record(() -> {
 			SampleReflection sample = new SampleReflection();
 			sample.multipleCalls(); // does Method[] methods = String.class.getMethods(); methods = Integer.class.getMethods();
 		});

settings.gradle

@@ -1,7 +1,6 @@
 plugins {
-	id "com.gradle.develocity" version "3.19"
-	id "io.spring.ge.conventions" version "0.0.17"
-	id "org.gradle.toolchains.foojay-resolver-convention" version "0.7.0"
+	id "io.spring.develocity.conventions" version "0.0.22"
+	id "org.gradle.toolchains.foojay-resolver-convention" version "0.9.0"
 }
 
 include "spring-aop"
@@ -14,7 +13,6 @@ include "spring-core"
 include "spring-core-test"
 include "spring-expression"
 include "spring-instrument"
-include "spring-jcl"
 include "spring-jdbc"
 include "spring-jms"
 include "spring-messaging"

spring-aop/spring-aop.gradle

@@ -5,12 +5,12 @@ apply plugin: "kotlin"
 dependencies {
 	api(project(":spring-beans"))
 	api(project(":spring-core"))
+	compileOnly("com.google.code.findbugs:jsr305") // for the AOP Alliance fork
 	optional("org.apache.commons:commons-pool2")
 	optional("org.aspectj:aspectjweaver")
 	optional("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")
 	testFixturesImplementation(testFixtures(project(":spring-beans")))
 	testFixturesImplementation(testFixtures(project(":spring-core")))
-	testFixturesImplementation("com.google.code.findbugs:jsr305")
 	testImplementation(project(":spring-core-test"))
 	testImplementation(testFixtures(project(":spring-beans")))
 	testImplementation(testFixtures(project(":spring-core")))

spring-aop/src/main/java/org/aopalliance/aop/package-info.java

@@ -1,4 +1,7 @@
 /**
  * The core AOP Alliance advice marker.
  */
+@NullMarked
 package org.aopalliance.aop;
+
+import org.jspecify.annotations.NullMarked;

spring-aop/src/main/java/org/aopalliance/intercept/ConstructorInterceptor.java

@@ -16,8 +16,6 @@
 
 package org.aopalliance.intercept;
 
-import javax.annotation.Nonnull;
-
 /**
  * Intercepts the construction of a new object.
  *
@@ -56,7 +54,6 @@ public interface ConstructorInterceptor extends Interceptor {
 	 * @throws Throwable if the interceptors or the target object
 	 * throws an exception
 	 */
-	@Nonnull
 	Object construct(ConstructorInvocation invocation) throws Throwable;
 
 }

spring-aop/src/main/java/org/aopalliance/intercept/ConstructorInvocation.java

@@ -18,8 +18,6 @@ package org.aopalliance.intercept;
 
 import java.lang.reflect.Constructor;
 
-import javax.annotation.Nonnull;
-
 /**
  * Description of an invocation to a constructor, given to an
  * interceptor upon constructor-call.
@@ -38,7 +36,6 @@ public interface ConstructorInvocation extends Invocation {
 	 * {@link Joinpoint#getStaticPart()} method (same result).
 	 * @return the constructor being called
 	 */
-	@Nonnull
 	Constructor<?> getConstructor();
 
 }

spring-aop/src/main/java/org/aopalliance/intercept/Invocation.java

@@ -16,7 +16,7 @@
 
 package org.aopalliance.intercept;
 
-import javax.annotation.Nonnull;
+import org.jspecify.annotations.Nullable;
 
 /**
  * This interface represents an invocation in the program.
@@ -34,7 +34,6 @@ public interface Invocation extends Joinpoint {
 	 * array to change the arguments.
 	 * @return the argument of the invocation
 	 */
-	@Nonnull
-	Object[] getArguments();
+	@Nullable Object[] getArguments();
 
 }

spring-aop/src/main/java/org/aopalliance/intercept/Joinpoint.java

@@ -18,8 +18,7 @@ package org.aopalliance.intercept;
 
 import java.lang.reflect.AccessibleObject;
 
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.jspecify.annotations.Nullable;
 
 /**
  * This interface represents a generic runtime joinpoint (in the AOP
@@ -49,23 +48,20 @@ public interface Joinpoint {
 	 * @return see the children interfaces' proceed definition
 	 * @throws Throwable if the joinpoint throws an exception
 	 */
-	@Nullable
-	Object proceed() throws Throwable;
+	@Nullable Object proceed() throws Throwable;
 
 	/**
 	 * Return the object that holds the current joinpoint's static part.
 	 * <p>For instance, the target object for an invocation.
 	 * @return the object (can be null if the accessible object is static)
 	 */
-	@Nullable
-	Object getThis();
+	@Nullable Object getThis();
 
 	/**
 	 * Return the static part of this joinpoint.
 	 * <p>The static part is an accessible object on which a chain of
 	 * interceptors is installed.
 	 */
-	@Nonnull
 	AccessibleObject getStaticPart();
 
 }

spring-aop/src/main/java/org/aopalliance/intercept/MethodInterceptor.java

@@ -16,8 +16,7 @@
 
 package org.aopalliance.intercept;
 
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Intercepts calls on an interface on its way to the target. These
@@ -55,7 +54,6 @@ public interface MethodInterceptor extends Interceptor {
 	 * @throws Throwable if the interceptors or the target object
 	 * throws an exception
 	 */
-	@Nullable
-	Object invoke(@Nonnull MethodInvocation invocation) throws Throwable;
+	@Nullable Object invoke(MethodInvocation invocation) throws Throwable;
 
 }

spring-aop/src/main/java/org/aopalliance/intercept/MethodInvocation.java

@@ -18,8 +18,6 @@ package org.aopalliance.intercept;
 
 import java.lang.reflect.Method;
 
-import javax.annotation.Nonnull;
-
 /**
  * Description of an invocation to a method, given to an interceptor
  * upon method-call.
@@ -38,7 +36,6 @@ public interface MethodInvocation extends Invocation {
 	 * {@link Joinpoint#getStaticPart()} method (same result).
 	 * @return the method being called
 	 */
-	@Nonnull
 	Method getMethod();
 
 }

spring-aop/src/main/java/org/aopalliance/intercept/package-info.java

@@ -1,4 +1,7 @@
 /**
  * The AOP Alliance reflective interception abstraction.
  */
+@NullMarked
 package org.aopalliance.intercept;
+
+import org.jspecify.annotations.NullMarked;

spring-aop/src/main/java/org/aopalliance/package-info.java

@@ -1,4 +1,7 @@
 /**
  * Spring's variant of the AOP Alliance interfaces.
  */
+@NullMarked
 package org.aopalliance;
+
+import org.jspecify.annotations.NullMarked;

spring-aop/src/main/java/org/springframework/aop/AfterReturningAdvice.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@ package org.springframework.aop;
 
 import java.lang.reflect.Method;
 
-import org.springframework.lang.Nullable;
+import org.jspecify.annotations.Nullable;
 
 /**
  * After returning advice is invoked only on normal method return, not if an
@@ -41,6 +41,6 @@ public interface AfterReturningAdvice extends AfterAdvice {
 	 * allowed by the method signature. Otherwise the exception
 	 * will be wrapped as a runtime exception.
 	 */
-	void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
+	void afterReturning(@Nullable Object returnValue, Method method, @Nullable Object[] args, @Nullable Object target) throws Throwable;
 
 }

spring-aop/src/main/java/org/springframework/aop/MethodBeforeAdvice.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2025 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@ package org.springframework.aop;
 
 import java.lang.reflect.Method;
 
-import org.springframework.lang.Nullable;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Advice invoked before a method is invoked. Such advices cannot
@@ -40,6 +40,6 @@ public interface MethodBeforeAdvice extends BeforeAdvice {
 	 * allowed by the method signature. Otherwise the exception
 	 * will be wrapped as a runtime exception.
 	 */
-	void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
+	void before(Method method, @Nullable Object[] args, @Nullable Object target) throws Throwable;
 
 }

spring-aop/src/main/java/org/springframework/aop/MethodMatcher.java

@@ -18,6 +18,8 @@ package org.springframework.aop;
 
 import java.lang.reflect.Method;
 
+import org.jspecify.annotations.Nullable;
+
 /**
  * Part of a {@link Pointcut}: Checks whether the target method is eligible for advice.
  *
@@ -94,7 +96,7 @@ public interface MethodMatcher {
 	 * @return whether there's a runtime match
 	 * @see #matches(Method, Class)
 	 */
-	boolean matches(Method method, Class<?> targetClass, Object... args);
+	boolean matches(Method method, Class<?> targetClass, @Nullable Object... args);
 
 
 	/**

spring-aop/src/main/java/org/springframework/aop/ProxyMethodInvocation.java

@@ -17,8 +17,7 @@
 package org.springframework.aop;
 
 import org.aopalliance.intercept.MethodInvocation;
-
-import org.springframework.lang.Nullable;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Extension of the AOP Alliance {@link org.aopalliance.intercept.MethodInvocation}
@@ -59,14 +58,14 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	 * @return an invocable clone of this invocation.
 	 * {@code proceed()} can be called once per clone.
 	 */
-	MethodInvocation invocableClone(Object... arguments);
+	MethodInvocation invocableClone(@Nullable Object... arguments);
 
 	/**
 	 * Set the arguments to be used on subsequent invocations in the any advice
 	 * in this chain.
 	 * @param arguments the argument array
 	 */
-	void setArguments(Object... arguments);
+	void setArguments(@Nullable Object... arguments);
 
 	/**
 	 * Add the specified user attribute with the given value to this invocation.
@@ -83,7 +82,6 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	 * @return the value of the attribute, or {@code null} if not set
 	 * @see #setUserAttribute
 	 */
-	@Nullable
-	Object getUserAttribute(String key);
+	@Nullable Object getUserAttribute(String key);
 
 }

spring-aop/src/main/java/org/springframework/aop/TargetClassAware.java

@@ -16,7 +16,7 @@
 
 package org.springframework.aop;
 
-import org.springframework.lang.Nullable;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Minimal interface for exposing the target class behind a proxy.
@@ -36,7 +36,6 @@ public interface TargetClassAware {
 	 * (typically a proxy configuration or an actual proxy).
 	 * @return the target Class, or {@code null} if not known
 	 */
-	@Nullable
-	Class<?> getTargetClass();
+	@Nullable Class<?> getTargetClass();
 
 }

spring-aop/src/main/java/org/springframework/aop/TargetSource.java

@@ -16,7 +16,7 @@
 
 package org.springframework.aop;
 
-import org.springframework.lang.Nullable;
+import org.jspecify.annotations.Nullable;
 
 /**
  * A {@code TargetSource} is used to obtain the current "target" of
@@ -42,8 +42,7 @@ public interface TargetSource extends TargetClassAware {
 	 * @return the type of targets returned by this {@link TargetSource}
 	 */
 	@Override
-	@Nullable
-	Class<?> getTargetClass();
+	@Nullable Class<?> getTargetClass();
 
 	/**
 	 * Will all calls to {@link #getTarget()} return the same object?
@@ -64,8 +63,7 @@ public interface TargetSource extends TargetClassAware {
 	 * or {@code null} if there is no actual target instance
 	 * @throws Exception if the target object can't be resolved
 	 */
-	@Nullable
-	Object getTarget() throws Exception;
+	@Nullable Object getTarget() throws Exception;
 
 	/**
 	 * Release the given target object obtained from the