Update Reference Documentation.

Closes: #3484

Author: christophstrobl

src/main/antora/modules/ROOT/pages/aot.adoc

@@ -29,7 +29,7 @@ If Ahead of Time compilation is enabled Spring Data can (depending on the actual
 * Repository Metadata in JSON format
 
 Each of the above is enabled by default.
-However, there users may fine tune the configuration with following options.
+However, users may fine-tune the configuration with the following options.
 
 [options = "autowidth",cols="1,1"]
 |===

src/main/antora/modules/ROOT/pages/auditing.adoc

@@ -3,13 +3,14 @@
 
 [[auditing.basics]]
 == Basics
-Spring Data provides sophisticated support to transparently keep track of who created or changed an entity and when the change happened.To benefit from that functionality, you have to equip your entity classes with auditing metadata that can be defined either using annotations or by implementing an interface.
+Spring Data provides sophisticated support to transparently keep track of who created or changed an entity and when the change happened.
+To benefit from that functionality, you have to equip your entity classes with auditing metadata that can be defined either using annotations or by implementing an interface.
 Additionally, auditing has to be enabled either through Annotation configuration or XML configuration to register the required infrastructure components.
 Please refer to the store-specific section for configuration samples.
 
 [NOTE]
 ====
-Applications that only track creation and modification dates are not required do make their entities implement <<auditing.auditor-aware,`AuditorAware`>>.
+Applications that only track creation and modification dates are not required to make their entities implement <<auditing.auditor-aware,`AuditorAware`>>.
 ====
 
 [[auditing.annotations]]

src/main/antora/modules/ROOT/pages/custom-conversions.adoc

@@ -1,3 +1,4 @@
+[[custom-conversions]]
 = Custom Conversions
 
 The following example of a Spring `Converter` implementation converts from a `String` to a custom `Email` value object:

src/main/antora/modules/ROOT/pages/dependencies.adoc

@@ -37,7 +37,7 @@ You can find a working example of using the BOMs in our https://github.com/sprin
     <groupId>org.springframework.data</groupId>
     <artifactId>spring-data-jpa</artifactId>
   </dependency>
-<dependencies>
+</dependencies>
 ----
 
 [[dependencies.spring-boot]]

src/main/antora/modules/ROOT/pages/entity-callbacks.adoc

@@ -77,11 +77,11 @@ class DefaultingEntityCallback implements BeforeSaveCallback<Person>, Ordered {
 	@Override
 	public Object onBeforeSave(Person entity, String collection) {                   <1>
 
-		if(collection == "user") {
-		    return // ...
+		if("user".equals(collection)) {
+			return …;
 		}
 
-		return // ...
+		return …;
 	}
 
 	@Override

src/main/antora/modules/ROOT/pages/kotlin.adoc

@@ -6,7 +6,7 @@ https://kotlinlang.org[Kotlin] is a statically typed language that targets the J
 
 Spring Data provides first-class support for Kotlin and lets developers write Kotlin applications almost as if Spring Data was a Kotlin native framework.
 
-The easiest way to build a Spring application with Kotlin is to leverage Spring Boot and its https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-kotlin.html[dedicated Kotlin support].
+The easiest way to build a Spring application with Kotlin is to leverage Spring Boot and its https://docs.spring.io/spring-boot/reference/features/kotlin.html[dedicated Kotlin support].
 This comprehensive https://spring.io/guides/tutorials/spring-boot-kotlin/[tutorial] will teach you how to build Spring Boot applications with Kotlin using https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].
 
 

src/main/antora/modules/ROOT/pages/kotlin/coroutines.adoc

@@ -32,7 +32,7 @@ Coroutines support is enabled when `kotlinx-coroutines-core`, `kotlinx-coroutine
 </dependency>
 ----
 
-NOTE: Supported versions `1.3.0` and above.
+NOTE: Supported versions `1.7.0` and above.
 
 [[kotlin.coroutines.reactive]]
 == How Reactive translates to Coroutines?

src/main/antora/modules/ROOT/pages/kotlin/null-safety.adoc

@@ -5,18 +5,17 @@ One of Kotlin's key features is https://kotlinlang.org/docs/null-safety.html[nul
 This makes applications safer through nullability declarations and the expression of "`value or no value`" semantics without paying the cost of wrappers, such as `Optional`.
 (Kotlin allows using functional constructs with nullable values. See this https://www.baeldung.com/kotlin/null-safety[comprehensive guide to Kotlin null safety].)
 
-Although Java does not let you express null safety in its type system, Spring Data API is annotated with https://jcp.org/en/jsr/detail?id=305[JSR-305] tooling friendly annotations declared in the `org.springframework.lang` package.
-By default, types from Java APIs used in Kotlin are recognized as https://kotlinlang.org/docs/reference/java-interop.html#null-safety-and-platform-types[platform types], for which null checks are relaxed.
-https://kotlinlang.org/docs/reference/java-interop.html#jsr-305-support[Kotlin support for JSR-305 annotations] and Spring nullability annotations provide null safety for the whole Spring Data API to Kotlin developers, with the advantage of dealing with `null` related issues at compile time.
-
-See xref:repositories/null-handling.adoc[Null Handling of Repository Methods] how null safety applies to Spring Data Repositories.
-
-[TIP]
+[NOTE]
 ====
-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 take Spring Data API null-safety into account. 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.
+As of Spring Framework 7 and Spring Data 4, Spring Data uses https://jspecify.dev/docs/start-here/[JSpecify] for nullability annotations.
+The earlier https://jcp.org/en/jsr/detail?id=305[JSR-305]-based `org.springframework.lang` annotations are deprecated and should no longer be relied upon.
+See xref:repositories/null-handling.adoc[Null Handling of Repository Methods] for the current recommended approach.
 ====
 
-NOTE: Generic type arguments, varargs, and array elements nullability are not supported yet, but should be in an upcoming release.
+Although Java does not let you express null safety in its type system, the Spring Data API is annotated with JSpecify annotations.
+By default, types from Java APIs used in Kotlin are recognized as https://kotlinlang.org/docs/reference/java-interop.html#null-safety-and-platform-types[platform types], for which null checks are relaxed.
+JSpecify annotations provide null safety for the whole Spring Data API to Kotlin developers, with the advantage of dealing with `null`-related issues at compile time.
+
+See xref:repositories/null-handling.adoc[Null Handling of Repository Methods] for details on how null safety applies to Spring Data repositories.
+
+NOTE: Generic type arguments, varargs, and array element nullability are not supported yet, but should be in an upcoming release.

src/main/antora/modules/ROOT/pages/kotlin/requirements.adoc

@@ -1,5 +1,5 @@
 [[kotlin.requirements]]
 = Requirements
 
-Spring Data supports Kotlin 1.3 and requires `kotlin-stdlib` (or one of its variants, such as `kotlin-stdlib-jdk8`) and `kotlin-reflect` to be present on the classpath.
-Those are provided by default if you bootstrap a Kotlin project via https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].
+Spring Data supports Kotlin 1.9 and above and requires `kotlin-stdlib` and `kotlin-reflect` to be present on the classpath.
+Those are provided by default if you bootstrap a Kotlin project via https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].

src/main/antora/modules/ROOT/pages/object-mapping.adoc

@@ -214,7 +214,7 @@ If you want Spring Data to use the factory method for object instantiation, anno
 == General recommendations
 
 * _Try to stick to immutable objects_ -- Immutable objects are straightforward to create as materializing an object is then a matter of calling its constructor only.
-Also, this avoids your domain objects to be littered with setter methods that allow client code to manipulate the objects state.
+Also, this avoids littering your domain objects with setter methods that allow client code to manipulate the object's state.
 If you need those, prefer to make them package protected so that they can only be invoked by a limited amount of co-located types.
 Constructor-only materialization is up to 30% faster than properties population.
 * _Provide an all-args constructor_ -- Even if you cannot or don't want to model your entities as immutable values, there's still value in providing a constructor that takes all properties of the entity as arguments, including the mutable ones, as this allows the object mapping to skip the property population for optimal performance.