.mvn/extensions.xml

@@ -3,6 +3,6 @@
 	<extension>
 		<groupId>io.spring.develocity.conventions</groupId>
 		<artifactId>develocity-conventions-maven-extension</artifactId>
-		<version>0.0.19</version>
+		<version>0.0.22</version>
 	</extension>
 </extensions>

.mvn/jvm.config

@@ -0,0 +1,10 @@
+--add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED
+--add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED
+--add-exports jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED
+--add-exports jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED
+--add-exports jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED
+--add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED
+--add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED
+--add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+--add-opens jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
+--add-opens jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED

Jenkinsfile

@@ -9,7 +9,7 @@ pipeline {
 
 	triggers {
 		pollSCM 'H/10 * * * *'
-		upstream(upstreamProjects: "spring-data-build/main", threshold: hudson.model.Result.SUCCESS)
+		upstream(upstreamProjects: "spring-data-build/3.4.x", threshold: hudson.model.Result.SUCCESS)
 	}
 
 	options {

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-commons</artifactId>
-	<version>3.4.0</version>
+	<version>3.4.5-SNAPSHOT</version>
 
 	<name>Spring Data Core</name>
 	<description>Core Spring concepts underpinning every Spring Data module.</description>
@@ -25,7 +25,7 @@
 	<parent>
 		<groupId>org.springframework.data.build</groupId>
 		<artifactId>spring-data-parent</artifactId>
-		<version>3.4.0</version>
+		<version>3.4.5-SNAPSHOT</version>
 	</parent>
 
 	<properties>
@@ -380,8 +380,20 @@
 	</profiles>
 
 	<repositories>
-
-
+		<repository>
+			<id>spring-snapshot</id>
+			<url>https://repo.spring.io/snapshot</url>
+			<snapshots>
+				<enabled>true</enabled>
+			</snapshots>
+			<releases>
+				<enabled>false</enabled>
+			</releases>
+		</repository>
+		<repository>
+			<id>spring-milestone</id>
+			<url>https://repo.spring.io/milestone</url>
+		</repository>
 	</repositories>
 
 </project>

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

@@ -5,7 +5,7 @@ Oliver Gierke; Thomas Darimont; Christoph Strobl; Mark Pollack; Thomas Risberg;
 :revdate: {localdate}
 :feature-scroll: true
 
-(C) 2008-2024 The original authors.
+(C) 2008-2025 The original authors.
 
 NOTE: Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically.
 

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

@@ -223,7 +223,7 @@ It's an established pattern to rather use static factory methods to expose these
 [[mapping.general-recommendations.override.properties]]
 === Overriding Properties
 
-Java's allows a flexible design of domain classes where a subclass could define a property that is already declared with the same name in its superclass.
+Java allows a flexible design of domain classes where a subclass could define a property that is already declared with the same name in its superclass.
 Consider the following example:
 
 [source,java]
@@ -326,7 +326,7 @@ data class Person(var id: String, val name: String) {
 ----
 
 Kotlin supports parameter optionality by allowing default values to be used if a parameter is not provided.
-When Spring Data detects a constructor with parameter defaulting, then it leaves these parameters absent if the data store does not provide a value (or simply returns `null`) so Kotlin can apply parameter defaulting.Consider the following class that applies parameter defaulting for `name`
+When Spring Data detects a constructor with parameter defaulting, then it leaves these parameters absent if the data store does not provide a value (or simply returns `null`) so Kotlin can apply parameter defaulting. Consider the following class that applies parameter defaulting for `name`
 
 [source,kotlin]
 ----

src/main/antora/modules/ROOT/pages/query-by-example.adoc

@@ -1,3 +1,7 @@
+ifndef::support-qbe-collection[]
+:support-qbe-collection: true
+endif::[]
+
 [[query-by-example]]
 = Query by Example
 
@@ -36,6 +40,9 @@ Query by Example is well suited for several use cases:
 Query by Example also has several limitations:
 
 * No support for nested or grouped property constraints, such as `firstname = ?0 or (firstname = ?1 and lastname = ?2)`.
+ifeval::[{support-qbe-collection} != true]
+* No support for matching collections or maps.
+endif::[]
 * Store-specific support on string matching.
 Depending on your databases, String matching can support starts/contains/ends/regex for strings.
 * Exact matching for other property types.

src/main/antora/modules/ROOT/pages/repositories/core-extensions-populators.adoc

@@ -0,0 +1,72 @@
+[[core.repository-populators]]
+= Repository Populators
+
+If you work with the Spring JDBC module, you are probably familiar with the support for populating a `DataSource` with SQL scripts.
+A similar abstraction is available on the repositories level, although it does not use SQL as the data definition language because it must be store-independent.
+Thus, the populators support XML (through Spring's OXM abstraction) and JSON (through Jackson) to define data with which to populate the repositories.
+
+Assume you have a file called `data.json` with the following content:
+
+.Data defined in JSON
+[source,javascript]
+----
+[ { "_class" : "com.acme.Person",
+ "firstname" : "Dave",
+  "lastname" : "Matthews" },
+  { "_class" : "com.acme.Person",
+ "firstname" : "Carter",
+  "lastname" : "Beauford" } ]
+----
+
+You can populate your repositories by using the populator elements of the repository namespace provided in Spring Data Commons.
+To populate the preceding data to your `PersonRepository`, declare a populator similar to the following:
+
+.Declaring a Jackson repository populator
+[source,xml]
+----
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:repository="http://www.springframework.org/schema/data/repository"
+  xsi:schemaLocation="http://www.springframework.org/schema/beans
+    https://www.springframework.org/schema/beans/spring-beans.xsd
+    http://www.springframework.org/schema/data/repository
+    https://www.springframework.org/schema/data/repository/spring-repository.xsd">
+
+  <repository:jackson2-populator locations="classpath:data.json" />
+
+</beans>
+----
+
+The preceding declaration causes the `data.json` file to be read and deserialized by a Jackson `ObjectMapper`.
+
+The type to which the JSON object is unmarshalled is determined by inspecting the `_class` attribute of the JSON document.
+The infrastructure eventually selects the appropriate repository to handle the object that was deserialized.
+
+To instead use XML to define the data the repositories should be populated with, you can use the `unmarshaller-populator` element.
+You configure it to use one of the XML marshaller options available in Spring OXM.
+See the {spring-framework-docs}/data-access/oxm.html[Spring reference documentation] for details.
+The following example shows how to unmarshall a repository populator with JAXB:
+
+.Declaring an unmarshalling repository populator (using JAXB)
+[source,xml]
+----
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:repository="http://www.springframework.org/schema/data/repository"
+  xmlns:oxm="http://www.springframework.org/schema/oxm"
+  xsi:schemaLocation="http://www.springframework.org/schema/beans
+    https://www.springframework.org/schema/beans/spring-beans.xsd
+    http://www.springframework.org/schema/data/repository
+    https://www.springframework.org/schema/data/repository/spring-repository.xsd
+    http://www.springframework.org/schema/oxm
+    https://www.springframework.org/schema/oxm/spring-oxm.xsd">
+
+  <repository:unmarshaller-populator locations="classpath:data.json"
+    unmarshaller-ref="unmarshaller" />
+
+  <oxm:jaxb2-marshaller contextPath="com.acme" />
+
+</beans>
+----

src/main/antora/modules/ROOT/pages/repositories/core-extensions-querydsl.adoc

@@ -0,0 +1,50 @@
+[[core.extensions.querydsl]]
+= Querydsl Extension
+
+http://www.querydsl.com/[Querydsl] is a framework that enables the construction of statically typed SQL-like queries through its fluent API.
+
+NOTE: Querydsl maintenance has slowed down to a point where the community has forked the project under OpenFeign at https://github.com/OpenFeign/querydsl (groupId `io.github.openfeign.querydsl`).
+Spring Data supports the fork on a best-effort basis.
+
+Several Spring Data modules offer integration with Querydsl through `QuerydslPredicateExecutor`, as the following example shows:
+
+.QuerydslPredicateExecutor interface
+[source,java]
+----
+public interface QuerydslPredicateExecutor<T> {
+
+  Optional<T> findById(Predicate predicate);  <1>
+
+  Iterable<T> findAll(Predicate predicate);   <2>
+
+  long count(Predicate predicate);            <3>
+
+  boolean exists(Predicate predicate);        <4>
+
+  // … more functionality omitted.
+}
+----
+
+<1> Finds and returns a single entity matching the `Predicate`.
+<2> Finds and returns all entities matching the `Predicate`.
+<3> Returns the number of entities matching the `Predicate`.
+<4> Returns whether an entity that matches the `Predicate` exists.
+
+To use the Querydsl support, extend `QuerydslPredicateExecutor` on your repository interface, as the following example shows:
+
+.Querydsl integration on repositories
+[source,java]
+----
+interface UserRepository extends CrudRepository<User, Long>, QuerydslPredicateExecutor<User> {
+}
+----
+
+The preceding example lets you write type-safe queries by using Querydsl `Predicate` instances, as the following example shows:
+
+[source,java]
+----
+Predicate predicate = user.firstname.equalsIgnoreCase("dave")
+	.and(user.lastname.startsWithIgnoreCase("mathews"));
+
+userRepository.findAll(predicate);
+----