spring-projects/spring-data-commons

This system is the foundational layer of the Spring Data framework, providing the core abstractions for entity mapping, repository composition, and data access across diverse storage backends. It enables type-safe property navigation, automatic auditing, and entity history tracking while supporting both synchronous and reactive programming models through interfaces like CrudRepository and ReactiveCrudRepository. The system also includes infrastructure for Ahead-of-Time (AOT) compilation, geospatial and vector search capabilities, and web integration for pagination and projection binding.

59 changes.

This period established the core infrastructure for Spring Data Commons, introducing foundational mapping, repository, and auditing subsystems with comprehensive support for immutable entities and Kotlin. It also modernized the framework by migrating to Jakarta EE namespaces, integrating Jackson 3, and adding Ahead-of-Time processing capabilities for native image builds.

32 changes.

This period focused on expanding Spring Data's capabilities for reactive programming and Kotlin, introducing dedicated repository interfaces for Project Reactor, RxJava 3, and Kotlin Coroutines. It also added significant new features including geospatial data types with JSON serialization, a refined projection infrastructure, and Querydsl web argument resolvers for MVC and WebFlux. The work was complemented by the introduction of an Entity Callback API for lifecycle hooks and extensive test coverage to ensure architectural stability and correct behavior across these new integrations.

30 changes.

This period focused on introducing Ahead-of-Time (AOT) processing infrastructure to support native image compilation, including runtime hints and build-time repository generation. It also established a new type-safe property path API using Java and Kotlin method references, replacing legacy string-based utilities.

A new Kotlin extension function \findByIdOrNull\ has been added to \CrudRepository\, allowing users to retrieve an entity by its ID and receive \null\ directly if the entity is not found, rather than handling an \Optional\.

src/main/kotlin/org/springframework/data/repository · high confidence

This change introduces new classes to support coordinating transactions across multiple Spring \PlatformTransactionManager\ instances. \MultiTransactionStatus\ acts as a composite \TransactionStatus\ that delegates commit, rollback, and savepoint operations to a map of underlying transaction managers, enabling best-effort multi-resource transaction handling. A new \SynchronizationManager\ interface and its \SpringTransactionSynchronizationManager\ implementation provide a strategy for delegating transaction synchronization lifecycle events (init, active check, clear) to Spring's core \TransactionSynchronizationManager\. Additionally, the legacy \ChangedSetBackedTransactionSynchronization\ class has been removed, cleaning up obsolete change-set tracking logic.

src/main/java/org/springframework/data/transaction · high confidence

A new \QuerydslHints\ class has been introduced in the \org.springframework.data.querydsl.aot\ package to register reflection hints required for bootstrapping Querydsl repositories at build time. This ensures that \Predicate\, \QuerydslPredicateExecutor\, and \ReactiveQuerydslPredicateExecutor\ types are preserved for runtime reflection when using Ahead-of-Time compilation, with specific support for Project Reactor if present.

src/main/java/org/springframework/data/querydsl/aot · high confidence

New XML Schema Definition (XSD) files have been added to the classpath to support JAXB marshalling and unmarshalling of Atom syndication formats and Spring Data pagination structures. The \atom.xsd\ file defines the structure for Atom feeds and entries (including elements like title, link, author, and content), while \spring-data-jaxb.xsd\ defines the schema for pagination objects such as page requests, page content, and sort orders. These resources enable applications to serialize and deserialize domain objects into standard Atom XML and Spring Data pagination XML formats.

src/main/resources/org/springframework/data/domain · high confidence

New formatters have been introduced to parse and print geo-spatial types. The DistanceFormatter converts strings in the format of a decimal followed by a metric abbreviation (e.g., '10.5 km') into Distance instances, while the PointFormatter parses comma-separated doubles (e.g., '52.5,13.4') into Point instances. These formatters are now available for use in Spring's conversion and formatting infrastructure.

src/main/java/org/springframework/data/geo/format · high confidence

A new \WebRuntimeHints\ class has been introduced to provide reflection hints for Spring Data web components in native images. This ensures that \PagedModel\, \PageMetadata\, and related Jackson converters are correctly registered for both Jackson 2 and Jackson 3, preventing runtime failures when serializing paginated data in GraalVM native images.

src/main/java/org/springframework/data/web/aot · high confidence

Added src/main/resources/META-INF/spring/aot.factories to register AOT processors and runtime hints required for native image builds. This includes BeanFactoryInitializationAotProcessor for managed types, BeanRegistrationAotProcessor for auditing, and RuntimeHintsRegistrars for repository, Querydsl, and web components, ensuring these features work correctly in ahead-of-time compiled environments.

src/main/resources/META-INF/spring · high confidence

Spring Data Core now provides Kotlin-specific extensions for building type-safe property paths. Developers can use the \toPropertyPath()\ extension on \KProperty1\ references to create \TypedPropertyPath\ instances, and compose nested paths using the \/\ operator (e.g., \Book::author / Author::name\). The \PropertyReference\ class also gains a \then()\ extension to append \KProperty\ segments to existing paths, enabling more idiomatic and type-safe query construction in Kotlin applications.

src/main/kotlin/org/springframework/data/core · high confidence

This release introduces the core Spring configuration metadata files required for XML-based setup and IDE support. The \spring.schemas\ file now maps repository namespace XSDs (versions 1.0 through 2.1, including HTTPS variants) to their local resources, while \spring.handlers\ registers the namespace handlers for the \repository\ and \keyvalue\ schemas. Additionally, \spring.factories\ configures internal extension points, including Kotlin bean info, custom collection support for Vavr and Eclipse Collections, and Jackson module registrations for both standard and Jackson 3. The \spring.tooling\ file provides IDE hints for the repository namespace.

src/main/resources/META-INF · high confidence

The repository has been initialized with the foundational structure for Spring Data Commons. This includes the Apache 2.0 license file, a comprehensive README with Maven configuration and build instructions, and a security policy for reporting vulnerabilities. To streamline development, Maven wrapper scripts (mvnw, mvnw.cmd) and a .gitignore file have been added, alongside contribution guidelines and a Sonargraph architecture description to enforce code structure.

(repo-wide) · high confidence

This change adds the core infrastructure for generating Spring Data repository implementations at build time (Ahead-of-Time). It introduces a new set of classes in the \org.springframework.data.repository.aot.generate\ package, including builders for repository classes, constructors, and query methods, alongside support for fragment metadata and bean definition decoration. The implementation also bundles a lightweight, non-free-compatible JSON parser to handle repository JSON metadata serialization, and provides an \ExpressionMarker\ to assist with SpEL expression evaluation in generated code. This lays the groundwork for faster startup and reduced memory footprint by pre-generating repository proxies and query methods.

src/main/java/org/springframework/data/repository/aot/generate · high confidence

This change introduces a new \EntityCallback\ API in the \org.springframework.data.mapping.callback\ package, providing a standardized way to intercept and modify entity lifecycle events. The package includes a base \EntityCallback\<T\>\ marker interface, along with \EntityCallbacks\ and \ReactiveEntityCallbacks\ managers for registering and invoking these hooks in both synchronous and reactive contexts. The implementation supports generic type binding to filter callbacks by domain type, allows ordering via Spring's \@Order\ annotation, and includes native image runtime hints for AOT compatibility. Additionally, the invoker logic has been updated to gracefully handle non-assignable lambda callbacks on Java 18+ by detecting specific class-cast exception messages.

src/main/java/org/springframework/data/mapping/callback · high confidence

This release adds a new Kotlin-specific repository API under the \org.springframework.data.repository.kotlin\ package, enabling developers to use Kotlin Coroutines for data access. The new \CoroutineCrudRepository\ interface provides standard CRUD operations (save, find, delete) as suspend functions or returning \Flow\ streams, while \CoroutineSortingRepository\ adds sorting capabilities. This allows Kotlin applications to leverage non-blocking, coroutine-based interactions with the persistence layer.

src/main/kotlin/org/springframework/data/repository/kotlin · high confidence

This change introduces the core types for the Spring Data history API, including the \RevisionMetadata\ interface (with a \RevisionType\ enum for tracking insert/update/delete operations), the \Revision\ wrapper for entity snapshots, and the \Revisions\ collection for accessing revision history. It also adds \AnnotationRevisionMetadata\ to extract revision data via annotations, \RevisionSort\ for ordering revisions, and applies JSpecify nullability annotations across the package.

src/main/java/org/springframework/data/history · high confidence

Spring Data now supports type-safe property navigation via the new PropertyReference and TypedPropertyPath interfaces in the core package. By leveraging Java method references (e.g., Person::getName) instead of string-based paths, these APIs provide compile-time type safety and refactoring support for accessing and composing nested domain properties. This change also introduces the CustomCollectionRegistrar SPI to allow registration of custom collection and map types, and adds a max traversal depth limit to property path parsing to prevent stack overflow vulnerabilities.

src/main/java/org/springframework/data/core · high confidence

Users can now construct repository queries using a new fluent interface via the \FluentQuery\ and \FetchableFluentQuery\ APIs, allowing method chaining for sorting, limiting, and projecting results. The \QueryByExampleExecutor\ and \ReactiveQueryByExampleExecutor\ have been extended to support this fluent query style through a new \findBy\ method. Additionally, the internal parameter handling has been refactored with the introduction of \ParametersSource\ and \DefaultParameters\, and the \QueryByExampleExecutor\ now includes a \ListQueryByExampleExecutor\ variant that returns \List\ results instead of \Iterable\ for more convenient collection handling.

src/main/java/org/springframework/data/repository/query · high confidence

The auditing subsystem now supports configuration via Spring's JavaConfig model alongside existing XML parsing. A new \AuditingConfiguration\ interface and its \AnnotationAuditingConfiguration\ implementation allow users to define auditing settings (such as \AuditorAware\ and \DateTimeProvider\ references) directly through annotation metadata. This is backed by \AuditingBeanDefinitionRegistrarSupport\, which registers the necessary \AuditingHandler\ beans programmatically, enabling a more modern, type-safe configuration approach for Spring Data auditing.

src/main/java/org/springframework/data/auditing/config · high confidence

The repository abstraction now includes \ListCrudRepository\ and \ListPagingAndSortingRepository\ interfaces that extend the existing \CrudRepository\ and \PagingAndSortingRepository\ respectively. These new interfaces return \List\ types instead of \Iterable\ for methods like \saveAll\, \findAll\, and \findAllById\, providing a more convenient and predictable collection type for users who prefer list semantics over generic iteration.

src/main/java/org/springframework/data/repository · high confidence

A new RevisionRepository interface has been added to the Spring Data repository API, enabling users to access and query historical revisions of entities. This interface extends the base Repository interface and provides methods to retrieve the last change revision, fetch all revisions for a specific entity ID, retrieve paged revisions with optional sorting, and find a specific entity state at a given revision number. Supporting classes include RevisionEntityInformation for managing revision metadata and package-level nullability annotations via JSpecify.

src/main/java/org/springframework/data/repository/history · high confidence

Spring Data Commons introduces a new AOT (Ahead-of-Time) processing infrastructure to support native image builds and optimized startup. This change adds the \AotMappingContext\ class, which provides a specialized mapping context for processing AOT contributions by capturing entity instantiators and property accessors, and the \DefaultAotContext\ class, which serves as the default implementation of the \AotContext\ interface to manage type configurations and reflective runtime hints during AOT processing.

spring-data-commons · high confidence

A new \RepositoryRuntimeHints\ component has been added to the \org.springframework.data.repository.aot.hint\ package to provide the reflection and proxy hints required for bootstrapping Spring Data repositories in ahead-of-time (AOT) compiled environments. This change ensures that key repository infrastructure classes, such as factory beans, metadata, and query executors (including reactive variants when Project Reactor is present), are registered for reflection access, and that necessary JDK proxies are configured for repository method contexts.

src/main/java/org/springframework/data/repository/aot/hint · high confidence

Spring Data now includes a dedicated configuration layer for Ahead-of-Time (AOT) processing, introducing the \AotRepositoryContext\ and \AotRepositoryInformation\ interfaces and implementations to capture repository metadata at build time. This change adds the \BootstrapMode\ enumeration, allowing applications to explicitly control repository initialization timing (DEFAULT, DEFERRED, or LAZY) to optimize startup performance. The \CustomRepositoryImplementationDetector\ has been introduced to handle the detection of custom repository implementations and fragments with improved scanning and filtering capabilities. Additionally, new factory beans like \PropertiesBasedNamedQueriesFactoryBean\ and \PersistentEntitiesFactoryBean\ reduce bean indirections, while the \RepositoryBeanDefinitionReader\ and \RepositoryBeanNameGenerator\ provide the necessary wiring to support these AOT-specific requirements.

src/main/java/org/springframework/data/repository/config · high confidence

Added a new \org.springframework.data.domain.jaxb\ package containing \XmlAdapter\ implementations for \Page\, \Pageable\, \Sort\, and \Order\ domain types. This enables direct marshalling and unmarshalling of these objects to and from XML representations (DTOs) using the Jakarta EE 9 JAXB API, facilitating integration with XML-based web services.

src/main/java/org/springframework/data/domain/jaxb · high confidence

The Querydsl binding package now exposes a set of new functional interfaces and factory components to customize how HTTP request parameters map to Querydsl predicates. Users can define custom logic via the new \MultiValueBinding\, \SingleValueBinding\, and \OptionalValueBinding\ interfaces, which allow fine-grained control over how collection, single, and optional values are bound to entity paths. The \QuerydslBindingsFactory\ centralizes the creation of \QuerydslBindings\ for domain types, supporting auto-detection of \QuerydslBinderCustomizer\ beans and a new \QuerydslBinderCustomizerDefaults\ interface for applying global customization rules across all entities. Additionally, the \QuerydslPredicateBuilder\ has been updated to leverage these new bindings and a thread-safe path cache, while the \QuerydslPredicate\ annotation now explicitly supports specifying a custom binder class.

src/main/java/org/springframework/data/querydsl/binding · high confidence

This release introduces new repository interfaces to expand Querydsl integration: \ListQuerydslPredicateExecutor\ provides list-returning query methods as an alternative to the existing \Iterable\-based \QuerydslPredicateExecutor\, and \ReactiveQuerydslPredicateExecutor\ adds reactive support for \Flux\ and \Mono\ results. The existing \QuerydslPredicateExecutor.findOne()\ method now returns \Optional\<T\>\ instead of a raw entity, and the package adopts JSpecify \@Nullable\ annotations to clarify nullability constraints for users.

src/main/java/org/springframework/data/querydsl · high confidence

This change introduces two new classes, QuerydslPredicateArgumentResolver and ReactiveQuerydslPredicateArgumentResolver, which allow Spring MVC and Spring WebFlux controllers to directly inject Querydsl Predicates from HTTP request parameters. The MVC resolver implements HandlerMethodArgumentResolver to process query parameters into a Predicate, while the reactive resolver implements SyncHandlerMethodArgumentResolver for WebFlux. Both rely on QuerydslBindingsFactory for binding configuration and are part of the new org.springframework.data.web.querydsl package, which is marked as null-safe via JSpecify annotations.

src/main/java/org/springframework/data/web/querydsl · high confidence

A new \org.springframework.data.spel.spi\ package has been introduced to allow users to extend the Spring Expression Language (SpEL) evaluation context. This package provides the \EvaluationContextExtension\ interface for exposing custom properties, functions, and root objects in standard evaluations, and the \ReactiveEvaluationContextExtension\ interface for doing the same in reactive contexts via \Mono\. These interfaces enable developers to register custom extensions that are accessible at the root of the evaluation context, with support for ordering and unique identification to resolve property name ambiguities.

src/main/java/org/springframework/data/spel/spi · high confidence

The \org.springframework.data.spel\ package now exposes a dedicated SPI for managing SpEL evaluation contexts, introducing the \EvaluationContextProvider\ and \ReactiveEvaluationContextProvider\ interfaces to allow centralized, configurable context creation. It also adds \ReactiveExtensionAwareEvaluationContextProvider\ to assemble contexts from reactive extensions and a \Functions\ utility to resolve SpEL function overloads by name and argument types, enabling more robust and reactive SpEL expression evaluation in Spring Data repositories.

src/main/java/org/springframework/data/spel · high confidence

This release introduces a new \org.springframework.data.aot\ package that provides the core infrastructure for processing Spring Data repositories and types ahead of time. It includes \AotContext\ and \AotTypeConfiguration\ to manage AOT settings and type hints, \ManagedTypesBeanFactoryInitializationAotProcessor\ to preprocess bean definitions, and specific processors like \AuditingBeanRegistrationAotProcessor\ to register runtime hints for auditing beans. This enables better compatibility with native image compilation by pre-registering reflection, proxy, and resource requirements.

src/main/java/org/springframework/data/aot · high confidence

A new TypeNames utility class has been added to the org.springframework.data.javapoet package to provide opinionated extensions for JavaPoet. This class offers static methods to convert Spring Data's ResolvableType and Class objects into JavaPoet TypeName instances, handling primitive wrappers, generic type resolution, and array types. This enables more robust type representation when generating code with JavaPoet within Spring Data contexts.

src/main/java/org/springframework/data/javapoet · high confidence

This release introduces a new expression evaluation infrastructure in the \org.springframework.data.expression\ package, providing the core abstractions for parsing and evaluating value expressions in query methods. The change adds the \ValueExpression\ interface for encapsulating parsed expression strings and evaluating them against a context, along with \ValueExpressionParser\ and \ValueParserConfiguration\ to handle the parsing of SpEL and property placeholder syntax. It also introduces \ValueEvaluationContext\ and \ValueEvaluationContextProvider\ to manage the environment and evaluation state, including a \ReactiveValueEvaluationContextProvider\ for reactive flows. These components work together to allow query methods to resolve dynamic values and dependencies during execution.

src/main/java/org/springframework/data/expression · high confidence

The \org.springframework.data.config\ package now includes helper classes (\BeanComponentDefinitionBuilder\, \ParsingUtils\, \TypeFilterParser\) and a \ConfigurationUtils\ interface to simplify the creation of custom Spring XML namespaces and JavaConfig. These utilities handle bean definition building, property extraction from XML elements, and type filter parsing, enabling more robust and standardized configuration support for Spring Data modules.

src/main/java/org/springframework/data/config · high confidence

This release introduces several new annotations to enhance entity mapping and metadata control: @AccessType allows explicit control over whether fields or properties are accessed; @Immutable marks persistent entities as immutable; @ReadOnlyProperty prevents specific fields from being persisted; @Reference helps define target types for object references; and @PersistenceCreator designates preferred constructors or factory methods for object creation. Existing annotations have also been updated: @TypeAlias is now meta-annotated with @Persistent to ensure it is included in the persistent entity metamodel, and @Transient now supports RECORD\_COMPONENT for Java records. Additionally, audit-related annotations (@CreatedBy, @CreatedDate, @LastModifiedBy, @LastModifiedDate) are standardized, and the package is marked with @NullMarked for null-safety validation.

src/main/java/org/springframework/data/annotation · high confidence

The repository core package now exposes dedicated interfaces for entity and repository metadata, including \EntityInformation\ (with a new \getRequiredId\ method), \EntityMetadata\, \CrudMethods\ (standardizing access to save, find, and delete operations), \RepositoryInformation\, and \RepositoryMetadata\ (enhanced with full type information and fragment support). Additionally, \RepositoryMethodContext\ and \RepositoryMethodContextHolder\ are introduced to allow optional exposure of the current repository method's metadata during invocation, enabling advanced use cases like auditing or dynamic behavior based on the invoked method.

src/main/java/org/springframework/data/repository/core · high confidence

The \org.springframework.data.domain\ package now includes core abstractions to support domain-driven design and advanced querying. For auditing, \Auditable\ and \AuditorAware\ interfaces allow entities to track creation and modification details, with \ReactiveAuditorAware\ added for reactive contexts. Domain eventing is supported via \@DomainEvents\ and \@AfterDomainEventPublication\ annotations on aggregate roots. Pagination and scrolling are enhanced with the \Window\ and \ScrollPosition\ types for keyset/offset-based navigation, alongside existing \Page\ and \Slice\ interfaces. Additionally, a new vector search foundation is introduced with \Vector\, \ScoringFunction\, \Similarity\, and \Score\ types to handle embeddings and similarity calculations.

src/main/java/org/springframework/data/domain · high confidence

This release introduces a comprehensive set of value objects for geospatial data, including Point, Distance, Box, Circle, Polygon, Metric, and Metrics, along with GeoResult and GeoPage to carry distance information with query results. To support serialization, it adds GeoModule for Jackson 2 and GeoJacksonModule for Jackson 3, enabling the (de)serialization of these new geo-spatial types in JSON payloads.

src/main/java/org/springframework/data/geo · high confidence

The mapping package now introduces a foundational set of interfaces and value objects to support entity mapping and property access. This includes the \PersistentEntity\ and \PersistentProperty\ interfaces for representing entity metadata, \PersistentPropertyAccessor\ and \PersistentPropertyPathAccessor\ for reading and writing property values (including support for immutable objects via wither methods), and \Association\/\AssociationHandler\ for modeling relationships. Additionally, \InstanceCreatorMetadata\, \PreferredConstructor\, and \FactoryMethod\ provide the infrastructure for creating entity instances via constructors or factory methods, while \IdentifierAccessor\ and \TargetAwareIdentifierAccessor\ standardize identifier retrieval.

src/main/java/org/springframework/data/mapping · high confidence

The projection subsystem has been expanded with new core components to support projections on repository queries. This includes the \EntityProjectionIntrospector\ for analyzing domain types and reachable properties, the \Accessor\ helper for abstracting property getters and setters, and the \MethodInterceptorFactory\ SPI for customizing proxy method handling. Additionally, \ProjectionInformation\ now exposes \getInputProperties()\ to distinguish between properties required for projection creation and those resolved dynamically, and \TargetAware\ provides access to the underlying proxy target instance.

src/main/java/org/springframework/data/projection · high confidence

Spring Data now supports converters that apply to specific properties rather than just global type pairs. This change introduces the \PropertyValueConverter\ SPI, along with \PropertyValueConversionService\ and \PropertyValueConversions\ to manage these targeted conversions. A new \ConverterBuilder\ API allows users to register these converters fluently using Java 8 lambdas. Additionally, the \convert\ package now includes built-in converters for JSR-310 date/time types (via \Jsr310Converters\) and support for jMolecules domain types (via \JMoleculesConverters\).

src/main/java/org/springframework/data/convert · high confidence

This location introduces the core reactive repository abstractions: ReactiveCrudRepository and ReactiveSortingRepository for Project Reactor (Mono/Flux), and RxJava3CrudRepository and RxJava3SortingRepository for RxJava 3 (Single/Maybe/Flowable/Completable). These interfaces provide standard CRUD and sorting operations using reactive streams, enabling developers to build non-blocking data access layers with their preferred reactive library.

src/main/java/org/springframework/data/repository/reactive · high confidence

This change introduces new utility classes in the repository utilities package to enhance reactive type handling and simplify transaction configuration. The new ReactiveWrapperConverters class provides automatic conversion support for reactive wrapper types (such as RxJava 3, Project Reactor, Kotlin Coroutines, and Smallrye Mutiny) by registering converters based on classpath availability, allowing seamless interoperability between different reactive libraries. Additionally, a new TxUtils class exposes a DEFAULT\_TRANSACTION\_MANAGER constant to standardize transaction manager bean name references across the framework.

src/main/java/org/springframework/data/repository/util · high confidence

This change introduces a new set of support classes in the \org.springframework.data.repository.support\ package to facilitate the invocation of repository methods and handle method parameters. Key additions include \RepositoryInvoker\ and \RepositoryInvokerFactory\ interfaces, along with \DefaultRepositoryInvokerFactory\, which manages the creation of invokers for different repository types (e.g., \CrudRepository\, \PagingAndSortingRepository\). The \AnnotationAttribute\ and \MethodParameters\ classes provide utilities for extracting annotation attributes and managing method parameters, including custom naming via annotations. Additionally, \QueryMethodParameterConversionException\ is introduced to handle conversion failures during query method execution, and \RepositoryInvocationInformation\ provides metadata about available repository methods. These classes collectively enhance the framework's ability to interact with repository implementations in a more flexible and type-safe manner.

src/main/java/org/springframework/data/repository/support · high confidence

This update introduces new support classes in the \org.springframework.data.support\ package: \IsNewStrategy\ and \PersistableIsNewStrategy\ for entity newness detection, \PageableExecutionUtils\ and \ReactivePageableExecutionUtils\ for optimized page construction, and \PlaceholderResolver\ for text resolution. Simultaneously, the legacy ChangeSet synchronization interfaces (\ChangeSetBacked\, \ChangeSetSynchronizer\) and the \SerializationStore\ annotation have been removed.

src/main/java/org/springframework/data/support · high confidence

This release introduces several new utility classes in the \org.springframework.data.util\ package to enhance type scanning, Kotlin support, and resource management. \AnnotatedTypeScanner\ provides a configurable way to find types with specific annotations on the classpath, including support for interfaces. \KotlinBeanInfoFactory\ and \KotlinReflectionUtils\ improve Kotlin integration by using Kotlin reflection to determine bean properties, handle value classes, and detect suspend functions. \Lazy\ offers a simple value type for delayed object creation with \orElse\ and \or\ fallback methods. Additionally, \CloseableIterator\ serves as a bridging data structure for streaming results with proper resource cleanup, and \DirectFieldAccessFallbackBeanWrapper\ extends \BeanWrapperImpl\ to fall back to direct field access when accessor methods are unavailable.

src/main/java/org/springframework/data/util · high confidence

This release introduces several new handler method argument resolvers and supporting classes in the web package to enhance request binding. It adds support for offset-based scrolling via \OffsetScrollPositionHandlerMethodArgumentResolver\ and its reactive counterpart, allowing controllers to accept \OffsetScrollPosition\ parameters. Sorting and pagination capabilities are expanded with \HateoasSortHandlerMethodArgumentResolver\ for URI enhancement and updated \PageableHandlerMethodArgumentResolverSupport\ with new configuration options like \oneIndexedParameters\. Additionally, the framework now supports binding JSON payloads to projection interfaces using the new \@ProjectedPayload\ and \@JsonPath\ annotations, facilitated by \ProxyingHandlerMethodArgumentResolver\ and \ProjectingJackson2HttpMessageConverter\.

src/main/java/org/springframework/data/web · high confidence

The web configuration module now includes support for Jackson 3 alongside the existing Jackson 2 support, allowing applications using the newer Jackson version to benefit from Spring Data's serialization features. Additionally, the framework introduces customizer interfaces for Pageable, Sort, and OffsetScrollPosition argument resolvers, giving users finer control over how these web arguments are processed. The configuration also registers a ProxyingHandlerMethodArgumentResolver to enhance projection handling in Spring MVC controllers.

src/main/java/org/springframework/data/web/config · high confidence

A new native-image configuration file for spring-data-commons has been added, registering the TypedPropertyPathFeature. This ensures that the feature is included in the reflection and proxy metadata during native image compilation, which is necessary for correct runtime behavior of Spring Data Commons in GraalVM native images.

src/main/resources/META-INF/native-image · high confidence

The auditing infrastructure in \org.springframework.data.auditing\ has been restructured to use a new \AuditableBeanWrapper\ interface and \AuditableBeanWrapperFactory\ for setting auditing values, replacing the previous reflection-based approach. The \MappingAuditableBeanWrapperFactory\ now leverages \PersistentPropertyAccessor\ and \PersistentPropertyPathAccessor\ to detect and populate auditing fields (such as \@CreatedBy\ and \@LastModifiedDate\) via mapping metadata, enabling support for nested object paths and immutable entities. Additionally, the \AuditingHandler\ and \ReactiveAuditingHandler\ have been updated to use these new factories, and the \Auditor\ value object was introduced to encapsulate auditor information.

src/main/java/org/springframework/data/auditing · high confidence

The CDI repository support has been updated to use the Jakarta EE 9 namespace (e.g., \jakarta.enterprise.\\ instead of \javax.enterprise.\\) and the JSpecify library for nullability annotations. This change ensures compatibility with modern Jakarta EE application servers and provides more robust type safety for null checks within the repository infrastructure.

src/main/java/org/springframework/data/repository/cdi · high confidence

The Kotlin property path utilities in the \mapping\ module, including \KPropertyPath\, \KIterablePropertyPath\, and the \toDotPath\/\asString\ extension functions, are now deprecated. Users should migrate to the equivalent extensions provided in the \org.springframework.data.core\ package to ensure continued support and access to updated functionality.

src/main/kotlin/org/springframework/data/mapping · high confidence

The mapping model now provides improved handling for Kotlin data classes by leveraging their compiler-generated copy methods for immutable property updates, ensuring that changes result in new instances rather than mutating existing ones. Additionally, the system now supports purely immutable entity types by introducing an instantiation-aware property accessor that creates new entity instances via persistence constructors or factory methods when properties are set, allowing seamless updates to objects that lack traditional setters.

src/main/java/org/springframework/data/mapping/model · high confidence

The repository initialization subsystem now supports Jackson 3 for JSON-based data loading, introducing new classes such as JacksonResourceReader and JacksonRepositoryPopulatorFactoryBean that use the tools.jackson.databind API. The previous Jackson 2 implementations (Jackson2ResourceReader and Jackson2RepositoryPopulatorFactoryBean) are now deprecated since version 4.0 and scheduled for removal, directing users to adopt the new Jackson 3-based components for initializing repositories from JSON resources.

src/main/java/org/springframework/data/repository/init · high confidence

The mapping context now exposes a richer API for resolving property paths, including methods to retrieve paths by dot notation and to find all property paths matching a specific predicate. When a path cannot be fully resolved, the system throws a new InvalidPersistentPropertyPath exception that provides detailed context, including the unresolvable segment and suggested property matches, to help users debug mapping issues.

src/main/java/org/springframework/data/mapping/context · high confidence

The query parser package now includes new helper classes \OrderBySource\ and \Part\ to handle sorting clauses and individual method-name parts for derived queries, alongside a \package-info.java\ that applies JSpecify \@NullMarked\ nullability constraints to the package.

src/main/java/org/springframework/data/repository/query/parser · high confidence

The \org.springframework.data.crossstore\ package has been restructured to support cross-store persistence, introducing the \ChangeSetBacked\ interface and \ChangeSetBackedTransactionSynchronization\ class to manage entity state and transaction outcomes. The \ChangeSet\ and \ChangeSetPersister\ interfaces were moved from \org.springframework.data.support\ to this new package and updated to use JSpecify annotations (\@Nullable\) for nullability constraints. Additionally, the \ChangeSetPersister\ API was refined to accept \ChangeSetBacked\ entity instances directly rather than their \Class\ objects, and the internal \NotFoundException\ was standardized with a serial version UID.

src/main/java/org/springframework/data/crossstore · high confidence

The repository core support package has been significantly restructured to introduce a new \RepositoryComposition\ and \RepositoryFragment\ model, allowing repositories to be composed of multiple implementation classes and custom method overrides. This change introduces new base classes like \AbstractRepositoryMetadata\ and \AbstractEntityInformation\, alongside specific implementations such as \DefaultRepositoryMetadata\ (for generic \Repository\ interfaces) and \AnnotationRepositoryMetadata\ (for \@RepositoryDefinition\ annotated interfaces). The diff also adds \DefaultRepositoryInformation\ to manage the composition of base classes and fragments, \MethodLookup\ strategies for resolving method implementations within composite repositories, and \QueryExecutionResultHandler\ for post-processing query results. Additionally, support for reactive repositories is formalized via \ReactiveRepositoryFactorySupport\, and new exception types like \FragmentNotImplementedException\ and \IncompleteRepositoryCompositionException\ are introduced to handle composition errors.

src/main/java/org/springframework/data/repository/core/support · high confidence

The Spring Data repository XML namespace schemas (XSDs) have been updated to support several new configuration capabilities. Users can now define a custom base class for repositories via the new \base-class\ attribute (replacing the deprecated \factory-class\), and control whether nested repository interfaces are scanned using the \consider-nested-repositories\ flag. JSON population is now supported via Jackson 2 (\jackson2-populator\), while the legacy Jackson 1 populator is deprecated. Additionally, auditing configuration has been expanded with a \modify-on-creation\ flag to control whether entities are marked as modified upon creation, and a \bootstrap-mode\ attribute has been introduced to manage repository initialization timing.

src/main/resources/org/springframework/data/repository · high confidence

Added ArchUnit tests for dependency cycles; Added HidingClassLoader test utility; Added JMH benchmarks for property path and lambda reader performance; Added Kotlin test fixtures for projection scenarios; Added Kotlin unit tests for query parameter handling; Added integration and unit tests for repository initialization; Added integration tests for ChainedTransactionManager; Added integration tests for Spring Data Web configuration; Added sample configurations for AOT repository processing tests; Added sample test fixtures for repository interfaces and configuration; Added test configuration for CDI extension and Spring factories; Added test fixture for Querydsl package suffix support; Added test fixtures for Kotlin mapping context tests; Added test fixtures for Spring Data AOT type processing; Added test fixtures for default package handling; Added test fixtures for repository and interface scenarios; Added test resources for JAXB integration and test configuration; Added test resources for Jackson 2 repository population; Added test utilities to exclude packages from the classpath; Added tests for AOT repository registration contributions; Added tests for CDI repository composition and fragment support; Added tests for Kotlin data class and value class mapping; Added tests for the findByIdOrNull extension; Added tests for the mapping context subsystem; Added unit and integration tests for Spring Data projection infrastructure; Added unit and integration tests for geo value objects and Jackson serialization; Added unit and integration tests for repository support components; Added unit tests for AOT repository generation infrastructure; Added unit tests for AuditingBeanDefinitionRegistrarSupport; Added unit tests for Distance and Point formatters; Added unit tests for JavaPoet code generation and type resolution; Added unit tests for KPropertyPath and its extensions; Added unit tests for Kotlin coroutine repository metadata; Added unit tests for Kotlin coroutine repository support; Added unit tests for Kotlin property path and reference APIs; Added unit tests for KotlinBeanInfoFactory; Added unit tests for PropertyValueConversionService; Added unit tests for QueryExecutionConverters and ReactiveWrapperConverters; Added unit tests for Querydsl binding components; Added unit tests for Querydsl predicate argument resolvers; Added unit tests for SpEL evaluation context infrastructure; Added unit tests for SpEL function and parameter type detection; Added unit tests for Spring Data AOT infrastructure; Added unit tests for Spring Data History components; Added unit tests for Spring Data JAXB conversions; Added unit tests for Spring Data conversion subsystem components; Added unit tests for Spring Data domain types; Added unit tests for Spring Data mapping core components; Added unit tests for Spring Data utility classes; Added unit tests for Spring Data web argument resolvers and serialization; Added unit tests for TypeAlias annotation scanning; Added unit tests for ValueExpression parsing and evaluation; Added unit tests for WebRuntimeHints registration logic; Added unit tests for core type, property, and conversion utilities; Added unit tests for data support utilities; Added unit tests for entity callback discovery and dispatch; Added unit tests for repository configuration infrastructure; Added unit tests for repository core support components; Added unit tests for repository query parameter handling and projection logic; Added unit tests for the Spring Data Auditing subsystem; Expanded test coverage for Spring Data mapping model components.

The Maven build now integrates the Spring Develocity Conventions extension (version 0.0.26) to enhance build performance and analytics via ge.spring.io. Additionally, the JVM configuration has been updated with specific --add-exports and --add-opens flags for JDK compiler modules and base libraries to support the new extension and ensure compatibility with the current JDK version.

.mvn · high confidence

The project artifact has been renamed from 'common' to 'spring-data-commons' and the version bumped to 4.2.0-SNAPSHOT, reflecting the move to the new Spring Data Core module. The build now inherits from the 'spring-data-parent' 4.2.0-SNAPSHOT, and dependencies have been updated to use Jakarta EE namespaces (e.g., 'jakarta.servlet', 'jakarta.xml.bind-api') instead of the legacy 'javax' packages. Additionally, the dependency list now includes 'tools.jackson.core:jackson-databind' alongside the existing 'com.fasterxml.jackson.core:jackson-databind', and optional dependencies for Spring modules like 'spring-oxm', 'spring-web', and 'spring-webflux' are explicitly declared.

(dependencies) · high confidence

The Maven Wrapper configuration has been updated to use Apache Maven 3.9.16. This ensures that the project builds with a consistent, specific version of Maven, improving build reproducibility across different development environments.

.mvn/wrapper · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 61 → 48 (-12.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 88 → 93 (+4.5)
• Architecture 98 → 65 (-32.8)
• Maturity 52 → 47 (-5.5)
• Readiness 60 → 63 (+3.1)
• Security 59 → 35 (-23.8)
• Domain Modelling 100 → 100 (+0.0)

• Change coupling: AotRepositoryBeanDefinitionPropertiesDecorator.java ↔ AotRepositoryCreator.java (src/main/java/org/springframework/data/repository/aot/generate/AotRepositoryBeanDefinitionPropertiesDecorator.java)
• Change coupling: AotRepositoryContext.java ↔ AotRepositoryInformation.java (src/main/java/org/springframework/data/repository/config/AotRepositoryContext.java)
• Change coupling: AotRepositoryInformation.java ↔ DefaultAotRepositoryContext.java (src/main/java/org/springframework/data/repository/config/AotRepositoryInformation.java)
• Change coupling: AotRepositoryInformation.java ↔ RepositoryRegistrationAotContribution.java (src/main/java/org/springframework/data/repository/config/AotRepositoryInformation.java)
• Change coupling: AotRepositoryInformation.java ↔ RepositoryRegistrationAotProcessor.java (src/main/java/org/springframework/data/repository/config/AotRepositoryInformation.java)
• Change coupling: DefaultAotRepositoryContext.java ↔ RepositoryBeanDefinitionReader.java (src/main/java/org/springframework/data/repository/config/DefaultAotRepositoryContext.java)
• Change coupling: DefaultAotRepositoryContext.java ↔ RepositoryRegistrationAotContribution.java (src/main/java/org/springframework/data/repository/config/DefaultAotRepositoryContext.java)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/mapping/callback/DefaultEntityCallbacks.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/mapping/model/ClassGeneratingPropertyAccessorFactory.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/web/PageableHandlerMethodArgumentResolver.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/web/SortHandlerMethodArgumentResolverSupport.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/querydsl/binding/PropertyPathInformation.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/web/ProjectingJackson2HttpMessageConverter.java)
• Duplicated block (12 lines × 2) (src/main/java/org/springframework/data/core/MemberDescriptor.java)
• Duplicated block (12 lines × 2) (src/main/java/org/springframework/data/mapping/model/ClassGeneratingEntityInstantiator.java)
• Duplicated block (12 lines × 2) (src/main/java/org/springframework/data/mapping/model/MappingInstantiationException.java)
• Duplicated block (12 lines × 2) (src/main/java/org/springframework/data/repository/init/Jackson2ResourceReader.java)
• Duplicated block (13 lines × 2) (src/main/java/org/springframework/data/spel/spi/ParameterTypes.java)
• …and 27 more

• Change coupling: OrderBySource.java ↔ Part.java (src/main/java/org/springframework/data/repository/query/parser/OrderBySource.java)
• Change coupling: PageableHandlerMethodArgumentResolverSupport.java ↔ SortHandlerMethodArgumentResolverSupport.java (src/main/java/org/springframework/data/web/PageableHandlerMethodArgumentResolverSupport.java)
• ClassTooLong: ClassGeneratingPropertyAccessorFactory (src/main/java/org/springframework/data/mapping/model/ClassGeneratingPropertyAccessorFactory.java)
• Coverage not measured — no coverage collector is wired up
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.adoc)
• Documentation: no licence statement (README.adoc)
• Documentation: no usage examples (README.adoc)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/auditing/config/AuditingBeanDefinitionRegistrarSupport.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/mapping/callback/DefaultEntityCallbacks.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/spel/spi/ParameterTypes.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/web/PageableHandlerMethodArgumentResolver.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/web/ProjectingJackson2HttpMessageConverter.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/web/SortHandlerMethodArgumentResolverSupport.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/web/config/SpringDataJackson3Configuration.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/core/NullableWrapperConverters.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/mapping/PersistentEntity.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/querydsl/binding/PropertyPathInformation.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/repository/core/support/RepositoryMethodInvoker.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/spel/spi/ParameterTypes.java)
• …and 545 more

• 17 commits — 16 feature/other, 1 fixes

• src/main — 10 commits
• (repo) — 2 commits
• (root) — 2 commits
• .github/workflows — 1 commit
• .mvn/extensions.xml — 1 commit
• src/test — 1 commit

• fix: Fix nested KPropertyPath rendering.
• change: Adapt to changes in Spring Framework.
• change: Add String to LocalTime converter.
• change: Add release train automation.
• change: Document Vavr collection types as query method parameters.
• change: Enter rampdown phase for 4.2.0-M1.
• change: Enter rampdown phase for 4.2.0-M2.
• change: Polishing.
• change: Polishing.
• change: Polishing.
• change: Polishing.
• change: Prepare next development iteration.
• change: Properly handle mixed property paths.
• change: Release version 4.2.0-M1 (2026.1.0).
• change: Remove the warn logging about params not annotated with @ProjectedPayload.
• change: Update Maven extensions.
• change: Update build config for correct notice and license.txt inclusion.

• Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

spring-projects/spring-data-commons was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.