Merge branch 'spring-projects:main' into main

Author: lucky8987

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

@@ -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/release-milestone.yml

@@ -2,8 +2,8 @@ name: Release Milestone
 on:
   push:
     tags:
-      - v6.2.0-M[1-9]
-      - v6.2.0-RC[1-9]
+      - v7.0.0-M[1-9]
+      - v7.0.0-RC[1-9]
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
 jobs:

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

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

@@ -50,7 +50,7 @@ public void apply(Project project) {
 			project.getPlugins().apply(CheckstylePlugin.class);
 			project.getTasks().withType(Checkstyle.class).forEach(checkstyle -> checkstyle.getMaxHeapSize().set("1g"));
 			CheckstyleExtension checkstyle = project.getExtensions().getByType(CheckstyleExtension.class);
-			checkstyle.setToolVersion("10.18.1");
+			checkstyle.setToolVersion("10.20.1");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
 			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();

framework-docs/antora-playbook.yml

@@ -36,4 +36,4 @@ runtime:
     failure_level: warn
 ui:
   bundle:
-    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.17/ui-bundle.zip
+    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.18/ui-bundle.zip

framework-docs/modules/ROOT/nav.adoc

@@ -60,6 +60,7 @@
 **** xref:core/expressions/language-ref/constructors.adoc[]
 **** xref:core/expressions/language-ref/variables.adoc[]
 **** xref:core/expressions/language-ref/functions.adoc[]
+**** xref:core/expressions/language-ref/varargs.adoc[]
 **** xref:core/expressions/language-ref/bean-references.adoc[]
 **** xref:core/expressions/language-ref/operator-ternary.adoc[]
 **** xref:core/expressions/language-ref/operator-elvis.adoc[]

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

@@ -33,11 +33,11 @@ arbitrary advice types. This section describes the basic concepts and standard a
 [[aop-api-advice-around]]
 === Interception Around Advice
 
-The most fundamental advice type in Spring is interception around advice.
+The most fundamental advice type in Spring is _interception around advice_.
 
-Spring is compliant with the AOP `Alliance` interface for around advice that uses method
-interception. Classes that implement `MethodInterceptor` and that implement around advice should also implement the
-following interface:
+Spring is compliant with the AOP Alliance interface for around advice that uses method
+interception. Classes that implement around advice should therefore implement the
+following `MethodInterceptor` interface from the `org.aopalliance.intercept` package:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -49,8 +49,8 @@ following interface:
 
 The `MethodInvocation` argument to the `invoke()` method exposes the method being
 invoked, the target join point, the AOP proxy, and the arguments to the method. The
-`invoke()` method should return the invocation's result: the return value of the join
-point.
+`invoke()` method should return the invocation's result: typically the return value of
+the join point.
 
 The following example shows a simple `MethodInterceptor` implementation:
 
@@ -64,9 +64,9 @@ Java::
 
 		public Object invoke(MethodInvocation invocation) throws Throwable {
 			System.out.println("Before: invocation=[" + invocation + "]");
-			Object rval = invocation.proceed();
+			Object result = invocation.proceed();
 			System.out.println("Invocation returned");
-			return rval;
+			return result;
 		}
 	}
 ----
@@ -79,9 +79,9 @@ Kotlin::
 
 		override fun invoke(invocation: MethodInvocation): Any {
 			println("Before: invocation=[$invocation]")
-			val rval = invocation.proceed()
+			val result = invocation.proceed()
 			println("Invocation returned")
-			return rval
+			return result
 		}
 	}
 ----
@@ -105,7 +105,7 @@ currently define pointcut interfaces.
 [[aop-api-advice-before]]
 === Before Advice
 
-A simpler advice type is a before advice. This does not need a `MethodInvocation`
+A simpler advice type is a _before advice_. This does not need a `MethodInvocation`
 object, since it is called only before entering the method.
 
 The main advantage of a before advice is that there is no need to invoke the `proceed()`
@@ -122,10 +122,6 @@ The following listing shows the `MethodBeforeAdvice` interface:
 	}
 ----
 
-(Spring's API design would allow for
-field before advice, although the usual objects apply to field interception and it is
-unlikely for Spring to ever implement it.)
-
 Note that the return type is `void`. Before advice can insert custom behavior before the join
 point runs but cannot change the return value. If a before advice throws an
 exception, it stops further execution of the interceptor chain. The exception
@@ -176,10 +172,10 @@ TIP: Before advice can be used with any pointcut.
 [[aop-api-advice-throws]]
 === Throws Advice
 
-Throws advice is invoked after the return of the join point if the join point threw
+_Throws advice_ is invoked after the return of the join point if the join point threw
 an exception. Spring offers typed throws advice. Note that this means that the
 `org.springframework.aop.ThrowsAdvice` interface does not contain any methods. It is a
-tag interface identifying that the given object implements one or more typed throws
+marker interface identifying that the given object implements one or more typed throws
 advice methods. These should be in the following form:
 
 [source,java,indent=0,subs="verbatim,quotes"]
@@ -189,9 +185,10 @@ advice methods. These should be in the following form:
 
 Only the last argument is required. The method signatures may have either one or four
 arguments, depending on whether the advice method is interested in the method and
-arguments. The next two listing show classes that are examples of throws advice.
+arguments. The next two listings show classes that are examples of throws advice.
 
-The following advice is invoked if a `RemoteException` is thrown (including from subclasses):
+The following advice is invoked if a `RemoteException` is thrown (including subclasses of
+`RemoteException`):
 
 [tabs]
 ======
@@ -220,9 +217,9 @@ Kotlin::
 ----
 ======
 
-Unlike the preceding
-advice, the next example declares four arguments, so that it has access to the invoked method, method
-arguments, and target object. The following advice is invoked if a `ServletException` is thrown:
+Unlike the preceding advice, the next example declares four arguments, so that it has
+access to the invoked method, method arguments, and target object. The following advice
+is invoked if a `ServletException` is thrown:
 
 [tabs]
 ======
@@ -304,7 +301,7 @@ TIP: Throws advice can be used with any pointcut.
 [[aop-api-advice-after-returning]]
 === After Returning Advice
 
-An after returning advice in Spring must implement the
+An _after returning advice_ in Spring must implement the
 `org.springframework.aop.AfterReturningAdvice` interface, which the following listing shows:
 
 [source,java,indent=0,subs="verbatim,quotes"]
@@ -368,7 +365,7 @@ TIP: After returning advice can be used with any pointcut.
 [[aop-api-advice-introduction]]
 === Introduction Advice
 
-Spring treats introduction advice as a special kind of interception advice.
+Spring treats _introduction advice_ as a special kind of interception advice.
 
 Introduction requires an `IntroductionAdvisor` and an `IntroductionInterceptor` that
 implement the following interface:

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

@@ -883,11 +883,12 @@ for example, for processing all events asynchronously and/or for handling listen
 == Convenient Access to Low-level Resources
 
 For optimal usage and understanding of application contexts, you should familiarize
-yourself with Spring's `Resource` abstraction, as described in xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources].
+yourself with Spring's `Resource` abstraction, as described in
+xref:core/resources.adoc[Resources].
 
 An application context is a `ResourceLoader`, which can be used to load `Resource` objects.
 A `Resource` is essentially a more feature rich version of the JDK `java.net.URL` class.
-In fact, the implementations of the `Resource` wrap an instance of `java.net.URL`, where
+In fact, implementations of `Resource` wrap an instance of `java.net.URL`, where
 appropriate. A `Resource` can obtain low-level resources from almost any location in a
 transparent fashion, including from the classpath, a filesystem location, anywhere
 describable with a standard URL, and some other variations. If the resource location

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

@@ -444,18 +444,27 @@ component. This section discusses both of these options.
 The compiler can operate in one of three modes, which are captured in the
 `org.springframework.expression.spel.SpelCompilerMode` enum. The modes are as follows.
 
-* `OFF` (default): The compiler is switched off.
-* `IMMEDIATE`: In immediate mode, the expressions are compiled as soon as possible. This
-  is typically after the first interpreted evaluation. If the compiled expression fails
-  (typically due to a type changing, as described earlier), the caller of the expression
-  evaluation receives an exception.
-* `MIXED`: In mixed mode, the expressions silently switch between interpreted and
-  compiled mode over time. After some number of interpreted runs, they switch to compiled
-  form and, if something goes wrong with the compiled form (such as a type changing, as
-  described earlier), the expression automatically switches back to interpreted form
-  again. Sometime later, it may generate another compiled form and switch to it.
-  Basically, the exception that the user gets in `IMMEDIATE` mode is instead handled
-  internally.
+`OFF` ::
+  The compiler is switched off, and all expressions will be evaluated in _interpreted_
+  mode. This is the default mode.
+`IMMEDIATE` ::
+  In immediate mode, expressions are compiled as soon as possible, typically after the
+  first interpreted evaluation. If evaluation of the compiled expression fails (for
+  example, due to a type changing, as described earlier), the caller of the expression
+  evaluation receives an exception. If the types of various expression elements change
+  over time, consider switching to `MIXED` mode or turning off the compiler.
+`MIXED` ::
+  In mixed mode, expression evaluation silently switches between _interpreted_ and
+  _compiled_ over time. After some number of successful interpreted runs, the expression
+  gets compiled. If evaluation of the compiled expression fails (for example, due to a
+  type changing), that failure will be caught internally, and the system will switch back
+  to interpreted mode for the given expression. Basically, the exception that the caller
+  receives in `IMMEDIATE` mode is instead handled internally. Sometime later, the
+  compiler may generate another compiled form and switch to it. This cycle of switching
+  between interpreted and compiled mode will continue until the system determines that it
+  does not make sense to continue trying — for example, when a certain failure threshold
+  has been reached — at which point the system will permanently switch to interpreted
+  mode for the given expression.
 
 `IMMEDIATE` mode exists because `MIXED` mode could cause issues for expressions that
 have side effects. If a compiled expression blows up after partially succeeding, it

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

@@ -3,39 +3,40 @@
 
 You can invoke constructors by using the `new` operator. You should use the fully
 qualified class name for all types except those located in the `java.lang` package
-(`Integer`, `Float`, `String`, and so on). The following example shows how to use the
-`new` operator to invoke constructors:
+(`Integer`, `Float`, `String`, and so on).
+xref:core/expressions/language-ref/varargs.adoc[Varargs] are also supported.
+
+The following example shows how to use the `new` operator to invoke constructors.
 
 [tabs]
 ======
 Java::
 +
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	Inventor einstein = p.parseExpression(
-			"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
+	Inventor einstein = parser.parseExpression(
+		"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
 			.getValue(Inventor.class);
 
 	// create new Inventor instance within the add() method of List
-	p.parseExpression(
-			"Members.add(new org.spring.samples.spel.inventor.Inventor(
-				'Albert Einstein', 'German'))").getValue(societyContext);
+	parser.parseExpression(
+		"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
+			.getValue(societyContext);
 ----
 
 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	val einstein = p.parseExpression(
-			"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
+	val einstein = parser.parseExpression(
+		"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
 			.getValue(Inventor::class.java)
 
 	// create new Inventor instance within the add() method of List
-	p.parseExpression(
-			"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
+	parser.parseExpression(
+		"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
 			.getValue(societyContext)
 ----
 ======
 
 
-

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

@@ -2,8 +2,12 @@
 = Functions
 
 You can extend SpEL by registering user-defined functions that can be called within
-expressions by using the `#functionName(...)` syntax. Functions can be registered as
-variables in `EvaluationContext` implementations via the `setVariable()` method.
+expressions by using the `#functionName(...)` syntax, and like with standard method
+invocations, xref:core/expressions/language-ref/varargs.adoc[varargs] are also supported
+for function invocations.
+
+Functions can be registered as _variables_ in `EvaluationContext` implementations via the
+`setVariable()` method.
 
 [TIP]
 ====
@@ -110,8 +114,9 @@ potentially more efficient use cases if the `MethodHandle` target and parameters
 been fully bound prior to registration; however, partially bound handles are also
 supported.
 
-Consider the `String#formatted(String, Object...)` instance method, which produces a
-message according to a template and a variable number of arguments.
+Consider the `String#formatted(Object...)` instance method, which produces a message
+according to a template and a variable number of arguments
+(xref:core/expressions/language-ref/varargs.adoc[varargs]).
 
 You can register and use the `formatted` method as a `MethodHandle`, as the following
 example shows:
@@ -151,10 +156,10 @@ Kotlin::
 ----
 ======
 
-As hinted above, binding a `MethodHandle` and registering the bound `MethodHandle` is also
-supported. This is likely to be more performant if both the target and all the arguments
-are bound. In that case no arguments are necessary in the SpEL expression, as the
-following example shows:
+As mentioned above, binding a `MethodHandle` and registering the bound `MethodHandle` is
+also supported. This is likely to be more performant if both the target and all the
+arguments are bound. In that case no arguments are necessary in the SpEL expression, as
+the following example shows:
 
 [tabs]
 ======
@@ -168,9 +173,10 @@ Java::
 	String template = "This is a %s message with %s words: <%s>";
 	Object varargs = new Object[] { "prerecorded", 3, "Oh Hello World!", "ignored" };
 	MethodHandle mh = MethodHandles.lookup().findVirtual(String.class, "formatted",
-			MethodType.methodType(String.class, Object[].class))
+		MethodType.methodType(String.class, Object[].class))
 			.bindTo(template)
-			.bindTo(varargs); //here we have to provide arguments in a single array binding
+			// Here we have to provide the arguments in a single array binding:
+			.bindTo(varargs);
 	context.setVariable("message", mh);
 
 	// evaluates to "This is a prerecorded message with 3 words: <Oh Hello World!>"
@@ -189,9 +195,10 @@ Kotlin::
 	val varargs = arrayOf("prerecorded", 3, "Oh Hello World!", "ignored")
 
 	val mh = MethodHandles.lookup().findVirtual(String::class.java, "formatted",
-			MethodType.methodType(String::class.java, Array<Any>::class.java))
+		MethodType.methodType(String::class.java, Array<Any>::class.java))
 			.bindTo(template)
-			.bindTo(varargs) //here we have to provide arguments in a single array binding
+			// Here we have to provide the arguments in a single array binding:
+			.bindTo(varargs)
 	context.setVariable("message", mh)
 
 	// evaluates to "This is a prerecorded message with 3 words: <Oh Hello World!>"
@@ -201,4 +208,3 @@ Kotlin::
 ======
 
 
-

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

@@ -1,9 +1,11 @@
 [[expressions-methods]]
 = Methods
 
-You can invoke methods by using typical Java programming syntax. You can also invoke methods
-on literals. Variable arguments are also supported. The following examples show how to
-invoke methods:
+You can invoke methods by using the typical Java programming syntax. You can also invoke
+methods directly on literals such as strings or numbers.
+xref:core/expressions/language-ref/varargs.adoc[Varargs] are supported as well.
+
+The following examples show how to invoke methods.
 
 [tabs]
 ======