Spring Data 2023.1 (Vaughan) Release Notes

General Themes

Virtual Thread usage through Executor configuration
Java 21 Compatibility
Support for Kotlin Value Classes
Explore optimizations for Checkpoint/Restore

Participating Modules

Details

Spring Data Build - 3.2
Spring Data Commons - 3.2
Spring Data JPA - 3.2
Spring Data Relational - 3.2
Spring Data MongoDB - 4.2
Spring Data Neo4j - 7.2
Spring Data Elasticsearch - 5.2
Spring Data Couchbase - 5.2
Spring Data for Apache Cassandra - 4.2
Spring Data Redis - 3.2
Spring Data REST - 4.2
Spring Data KeyValue - 3.2
Spring Data LDAP - 3.2

New and Noteworthy

Spring Data Commons - 3.2

Kotlin Value Classes

Kotlin Value Classes are a language feature that allows creating a wrapper class around single values with reduced heap allocations. Value classes are inlined on the JVM. Inlining results in flattening the value type into the property declaration site. Usage of Value classes imposes name mangling, introduces specific behavior to Copy methods, and how constructors are generated by Kotlin.

Spring Data now can:

Instantiate classes that define properties using Kotlin Value Classes
Retrieve and set properties using getters/setters and the copy method (for Data classes)

Value classes such as the following example can now be used for persistence operations:

@JvmInline
value class Email(val email : String)

data class Person(@Id val id: String, val email : Email)

Note that Kotlin inlining rules can require Value boxing type usage if the component is a primitive or if values use inner nullability. This results in the compiled class using the Value class as the property type instead of the Value type. Stores such as MongoDB will represent such models using subdocuments, so you want to watch out for type nullability to avoid type changes, especially for existing data.

`Limit` for Repository Query Methods

Limiting result sizes worked in the past by either using the Top…/First… keywords (as in findTop10By) or PageRequest when using pagination. With the recent introduction of ScrollPosition, PageRequest isn’t applicable and a static limit is sometimes not what your use case requires. Spring Data 3.2 ships a Limit type to specify the number of results to be returned dynamically:

interface UserRepository {
    List<User> findByLastname(String lastname, Limit limit);
}

repository.findByLastname("White", Limit.of(10));

repository.findByLastname("White", Limit.unlimited());

Spring Data JPA - 3.2

Spring Data Relational - 3.2

Liquibase ChangeSet Writer

When working with SQL databases, the schema is an essential part. Spring Data JDBC supports a wide range of schema options yet when starting with a domain model it can take time to come up with an initial domain model. To help you with a code-first approach, Spring Data JDBC ships with an integration to create database changesets using Liquibase.

LiquibaseChangeSetWriter is the core class to create change sets. The writer can operate in two modes:

Initial Schema Creation (without an existing database)
Differential Schema Migration (against a database connected via JDBC).

Consider the following example:

H2Database h2Database = new H2Database();
h2Database.setConnection(new JdbcConnection(c));

File changelogYml = new File(new File("my/directory"), "changelog.yml");

LiquibaseChangeSetWriter writer = new LiquibaseChangeSetWriter(relationalMappingContext);
writer.writeChangeSet(new FileSystemResource(changelogYml));

LiquibaseChangeSetWriter inspects all known entities in the RelationalMappingContext and writes a changeset to an existing (or new) changelog file.

SpEL support though `@Table` and `@Column` annotations

Mapping annotations for the table and column name respective mapped collections now accept SpEL expressions to determine table and column names at runtime using expressions.

@Table("#{myTenantController.getPersonTableName()}")
static class Person {
    @Id
    @Column("#{myTenantController.getIdentifierColumnName()}") Long id;
}

Expression evaluation leverages Spring Data’s EvaluationContextExtension mechanism in which extension beans can contribute SpEL functionality. Note that expression results are used as table/column names. These are sanitized through a default SqlIdentifierSanitizer.words(), allowing characters and underscores to limit impact of unwanted SQL characters. A different sanitizer can be configured through RelationalMappingContext.

Single Query Loading

Spring Data JDBC now allows the use of Single Query Loading. With this an arbitrary number of aggregates can be fully loaded with a single SQL query. This should be significant more efficient, especially for complex aggregates, consisting of many entities.

Currently this feature is very restricted.

It only works for aggregates that only reference one entity collection. The plan is to remove this constraint in the future.
The aggregate must also not use AggregateReference or embedded entities. The plan is to remove this constraint in the future.
The database dialect must support it. Of the dialects provided by Spring Data JDBC all but H2 and HSQL support this. H2 and HSQL don’t support analytic functions (aka windowing functions).
It only works for the find methods in CrudRepository, not for derived queries and not for annotated queries. The plan is to remove this constraint in the future.
Single Query Loading needs to be enabled in the JdbcMappingContext, by calling setSingleQueryLoadingEnabled(true)

If you are interested in further progress and plans for this feature, please follow https://github.com/spring-projects/spring-data-relational/issues/1445

Note: Single Query Loading is to be considered experimental. We appreciate feedback on how it works for you.

Note:Single Query Loading can be abbreviated as SQL, but we highly discourage that since confusion with Structured Query Language is almost guaranteed.

Spring Data MongoDB - 4.2

Spring Data Neo4j - 7.2

Spring Data Elasticsearch - 5.2

Spring Data Couchbase - 5.2

Spring Data for Apache Cassandra - 4.2

`CassandraScrollPosition` wrapper for Paging State

Spring Data Cassandra provides now a CassandraScrollPosition to leverage scrolling queries returning Window<T>. Scrolling is a much more natural fit than pagination through Slice. It allows you also to use WindowIterator to use Cassandra’s fetch size (pagination) to scroll across large results:

WindowIterator<Person> iterator = WindowIterator
		.of(scrollPosition -> personRepository.findAllWindowByLastname("White", scrollPosition, Limit.of(2)))
		.startingAt(CassandraScrollPosition.initial());

Spring Data Redis - 3.2

Reversed `RedisList`

With Java 21 introducing SequencedCollection, we had to revisit our RedisList as it implements List and Deque. Both types return a reversed view of their underlying collection, however since Java doesn’t provide a union type combining List and Deque, we moved ahead and made our RedisList compatible with the newly introduced library functionality. You can use the reversed view of RedisList with Java 17 already. On Java 21, the RedisList.reversed() method matches the SequencedCollection.reversed() signature.

RedisList<Person> list = …;

list.reversed().stream(); // consume the underlying list with reversed semantics

Lifecycle-bound `RedisConnectionFactory`

For our efforts on Checkpoint/Restore, we refactored Jedis and Lettuce RedisConnectionFactory to Lifecycle beans. Connection factories can be started, stopped, and restarted. By default, connection factories are started upon initialization (i.e. afterPropertiesSet) to retain existing functionality. Connection factories can be stopped to shut down connections and connection pools to take a snapshot and restarted when starting from a checkpoint snapshot.