All Classes and Interfaces
Class
Description
Convenience base class for aggregate roots that exposes a
AbstractAggregateRoot.registerEvent(Object) to capture domain events and
expose them via AbstractAggregateRoot.domainEvents().Base class for implementations of
EntityInformation.Base class to build mapping metadata and thus create instances of
PersistentEntity and
PersistentProperty.Abstract Java Bean implementation of
Pageable.Simple implementation of
PersistentProperty.Base class for query creators that create criteria based queries from a
PartTree.Base class for
RepositoryMetadata implementations.Base class for
FactoryBeans creating ResourceReaderRepositoryPopulators.Access options when using
PersistentPropertyPathAccessor to get and set properties.Access options for getting values for property paths.
How to handle null values during a
PersistentPropertyPath traversal.Access options for setting values for property paths.
How to propagate setting values that cross collection and map properties.
How to handle intermediate null values when setting
Helper value to abstract an accessor.
Annotation to define how Spring Data shall access values of persistent properties.
Annotation to be used on a method of a Spring Data managed aggregate to get invoked after the events of an aggregate
have been published.
A container object which may or may not contain a type alias value.
Scanner to find types with annotations on the classpath.
Default implementation for
AuditingConfiguration.Special
PersistentProperty that takes annotations at a property into account.A
ReflectionUtils.FieldCallback that will inspect each field for a given annotation.ReflectionUtils.MethodCallback to find annotations of a given type.Annotation based
RepositoryConfigurationSource.RepositoryMetadata implementation inspecting the given repository interface for a
RepositoryDefinition annotation.A
RevisionMetadata implementation that inspects the given object for fields with the configured annotations
and returns the field's values on calls to AnnotationRevisionMetadata.getRevisionInstant(), AnnotationRevisionMetadata.getRevisionInstant() and
AnnotationRevisionMetadata.getRevisionNumber().The context in which the AOT processing happens.
Interface defining introspection methods for bean definitions.
Type-based introspector to resolve
Class from a type name and to introspect the bean factory for presence
of beans.AotContext specific to Spring Data Repository infrastructure.Value object to capture
Associations.Callback interface to implement functionality to be applied to a collection of
Associations.Interface for auditable entities.
Interface to abstract the ways setting the auditing information can be implemented.
A factory to lookup
AuditableBeanWrappers.A
ImportBeanDefinitionRegistrar that serves as a base class for store specific implementations for
configuring audit support.Configuration information for auditing.
Auditing handler to mark entity objects created and modified.
Support class to implement auditing handlers.
Interface for components that are aware of the application's current auditor.
Simple value object to capture information of
PersistentEntitys.Helper to create
BeanComponentDefinition more easily.Simple helper to allow lenient lookup of beans of a given type from a
ListableBeanFactory.PersistentPropertyAccessorFactory that uses a
BeanWrapper.Enumeration to define in which way repositories are bootstrapped.
Represents a geospatial box value
FieldNamingStrategy that abbreviates field names by using the very first letter of the camel case parts of
the PersistentProperty's name.Configurable
FieldNamingStrategy that splits up camel-case property names and reconcatenates them using a
configured delimiter.Base class for
Bean wrappers.Interface containing the configurable options for the Spring Data repository subsystem using CDI.
Context for CDI repositories.
Base class for
Extension implementations that create instances for Spring Data repositories.Deprecated.
since 2.5
Interface representing the set of changes in an entity.
Interface introduced to objects exposing ChangeSet information
Interface to be implemented by classes that can synchronize between data stores and ChangeSets.
Exception thrown in alternate control flow if getPersistentState finds no entity data.
Represents a geospatial circle value
A factory that can generate byte code to speed-up dynamic property access.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0 to go package protected at some point.
Utility class to work with classes.
A
CloseableIterator serves as a bridging data structure for the underlying data store specific results that
can be wrapped in a Java 8 java.util.stream.Stream.TypeInformationMapper implementation that can be either set up using a MappingContext or manually set
up Map of String aliases to types.Helper class to centralize common functionality that needs to be used in various places of the configuration
implementation.
API to easily set up
GenericConverter instances using Java 8 lambdas, mostly in bidirectional fashion for
easy registration as custom type converters of the Spring Data mapping subsystem.A
ConverterBuilder aware of both a reading and writing converter.Exposes a reading converter.
Interface to represent an intermediate setup step of
ConverterBuilder.ConverterAware defining a reading converter first.Exposes a writing converter.
Interface to represent an intermediate setup step of
ConverterBuilder.ConverterAware defining a writing converter first.PersistentPropertyAccessor that potentially converts the value handed to
ConvertingPropertyAccessor.setProperty(PersistentProperty, Object) to the type of the PersistentProperty using a
ConversionService.Declares a field as the one representing the principal that created the entity containing the field.
Declares a field as the one representing the date the entity containing the field was created.
Meta-information about the CRUD methods of a repository.
Interface for generic CRUD operations on a repository for a specific type.
Default
DateTimeProvider simply creating new LocalDateTime instances for each method call.An SPI to register custom collection types.
Central API to expose information about custom collections present for Spring Data.
Value object to capture custom conversion.
Value object holding the actual
CustomConversions.StoreConversions and custom converters configured for
registration.Value class tying together a
CustomConversions.ConverterRegistration and its origin to allow fine
grained registration based on store supported types.Value type to capture store-specific extensions to the
CustomConversions.Value object to create custom
Metrics on the fly.Detects the custom implementation for a
Repository instance.SPI to calculate the current time to be used when auditing.
Default implementation to discover CRUD methods based on the given
RepositoryMetadata.Method interceptor to invoke default methods on the repository proxy.
Default implementation of
Parameters.Placeholder class to be used in
@Enable annotation's repositoryBaseClass attribute.Default implementation of
RepositoryConfiguration.Default implementation of
RepositoryInvokerFactory to inspect the requested repository type and create a
matching RepositoryInvoker that suits the repository best.Default implementation of
RepositoryMetadata.ParameterValueProvider implementation that evaluates the Parameters key against
SpelExpressionParser and EvaluationContext.Default implementation of
TypeMapper.Useful base class to implement custom
EntityInformations and delegate execution of standard methods from
EntityInformation to a special implementation.Custom extension of
BeanWrapperImpl that falls back to direct field access in case the object or type being
wrapped does not use accessor methods.Value object to represent distances in a given metric.
Converter to convert arbitrary input into domain classes managed
by Spring Data CrudRepositorys.DomainEvents can be used on methods of aggregate roots managed by Spring Data repositories to publish the
events returned by that method as Spring application events.Spring
Converter to create instances of the given DTO type from the source value handed into the conversion.Annotation to mark repository interfaces to be instantiated eagerly in a CDI context.
Annotation to automatically register the following beans for usage with Spring MVC.
Import selector to register
QuerydslWebConfiguration as configuration class if Querydsl is on the
classpath.Import selector to import the appropriate configuration class depending on whether Spring HATEOAS is present on the
classpath.
Marker interface for entity callbacks to be implemented in specific callback subtypes.
Interface to be implemented by objects that can manage a number of
EntityCallback objects and invoke these
with a specific entity.Combined
EntityReader and EntityWriter and add the ability to access a MappingContext and
ConversionService.Extension of
EntityMetadata to add functionality to query information of entity instances.SPI to abstract strategies to create instances for
PersistentEntitys.Simple value object allowing access to
EntityInstantiator instances for a given type falling back to a
default one.Metadata for entity types.
Strategy interface to abstract the ways to translate an plain domain class into a
EntityPath.Descriptor for a top-level mapped type representing a view onto a domain type structure.
Descriptor for a property-level type along its potential projection that is held within a
Collection-like
or Map-like container.Projection type.
Descriptor for a property-level type along its potential projection.
This class is introspects the returned type in the context of a domain type for all reachable properties (w/o cycles)
to determine which property paths are subject to projection.
Represents a predicate (boolean-valued function) of a
target type and its underlying
type.Interface to read object from store specific sources.
Interface to write objects into store specific sinks.
SPI to allow adding a set of properties and function definitions accessible via the root of an
EvaluationContext provided by an
ExtensionAwareQueryMethodEvaluationContextProvider.Provides a way to access a centrally defined potentially shared
StandardEvaluationContext.RepositoryProxyPostProcessor to register a MethodInterceptor to intercept
CrudRepository.save(Object) and CrudRepository.delete(Object) methods and publish events potentially
exposed via a method annotated with DomainEvents.Support for query by example (QBE).
Specification for property path matching to use in query by example (QBE).
A generic property matcher that specifies
string matching and case sensitivity.Predefined property matchers to create a
ExampleMatcher.GenericPropertyMatcher.Callback to configure a matcher.
The match modes to expose so that clients can find about how to concatenate the predicates.
Null handling for creating criterion out of an
Example.Define specific property handling for a Dot-Path.
Define specific property handling for Dot-Paths.
Allows to transform the property value before it is used in the query.
Match modes for treatment of
String values.Accessor for the
ExampleMatcher to use in modules that support query by example (QBE) querying.Value object capturing dependencies to a method or property/field that is referenced from a SpEL expression.
Value object to describe a dependency to a method or property/field that is referenced from a SpEL expression.
An
EvaluationContextProvider that assembles an EvaluationContext from a list of
EvaluationContextExtension instances.An
QueryMethodEvaluationContextProvider that assembles an EvaluationContext from a list of
EvaluationContextExtension instances.Marker interface for Spring Data
EvaluationContext extensions.Value object to encapsulate the factory method to be used when mapping persistent data to objects.
SPI to determine how to name document fields in cases the field name is not manually defined.
Fluent interface to define and run a query along with projection and sorting and.
Fetchable extension
FluentQuery allowing to materialize results from the underlying query.Reactive extension
FluentQuery allowing to materialize results from the underlying query.Value object for a discovered Repository fragment interface.
Exception thrown during repository creation or repository method invocation when invoking a repository method on a
fragment without an implementation.
Value object to represent a function.
Custom module to deserialize the geo-spatial value objects using Jackson 2.
Value object capturing some arbitrary object plus a distance.
Value object to capture
GeoResults as well as the average distance they have.Simple ChangeSet implementation backed by a HashMap.
JavaConfig class to register
PagedResourcesAssembler, PagedResourcesAssemblerArgumentResolver,
SlicedResourcesAssembler and SlicedResourcesAssemblerArgumentResolver.Extension of
PageableHandlerMethodArgumentResolver that also supports enhancing URIs using Spring HATEOAS
support.Extension of
SortHandlerMethodArgumentResolver that also supports enhancing URIs using Spring HATEOAS
support.Demarcates an identifier.
Interface for a component allowing the access of identifier values.
Default implementation of
IdentifierAccessor.Annotation for persistent entities to indicate the class is designed in immutable way.
Expresses configuration to be used to detect implementation classes for repositories and repository fragments.
Configuration that's used to lookup an implementation type for a repository or fragment interface.
Exception thrown during repository creation when a the repository has custom methods that are not backed by a
fragment or if no fragment could be found for a repository method invocation.
Metadata describing a mechanism to create instances of persistent types.
A
PersistentPropertyAccessor that will use an entity's
PersistenceCreator to create a new instance of it to apply a new value
for a given PersistentProperty.Delegating
PersistentPropertyAccessorFactory decorating the PersistentPropertyAccessors created with
an InstantiationAwarePropertyAccessor to allow the handling of purely immutable types.Exception to indicate a source path couldn't be resolved into a
PersistentPropertyPath completely.AuditingHandler extension that uses PersistentEntity.isNew(Object) to expose a generic
IsNewAwareAuditingHandler.markAudited(Object) method that will route calls to AuditingHandler.markCreated(Object) or
AuditingHandler.markModified(Object) based on the IsNewStrategy determined from the factory.AuditingHandlerBeanDefinitionParser that will register am IsNewAwareAuditingHandler.Strategy interface to determine whether a given entity is to be considered new.
A
ResourceReader using Jackson to read JSON into objects.Registers jMolecules converter implementations with
CustomConversions if the former is on the classpath.Annotation to explicitly declare a JSON Path expression on a projection interface.
MethodInterceptorFactory to create a MethodInterceptor that willHelper class to register JSR-310 specific
Converter implementations in case the we're running on Java 8.A
ScrollPosition based on the last seen key set.Value object representing defaulting masks used for Kotlin methods applying parameter defaulting.
Reflection utility methods specific to Kotlin reflection.
Declares a field as the one representing the principal that recently modified the entity containing the field.
Declares a field as the one representing the date the entity containing the field was recently modified.
Simple value type to delay the creation of an object using a
Supplier returning the produced object for
subsequent lookups.Interface for generic CRUD operations on a repository for a specific type.
Repository fragment to provide methods to retrieve entities using the pagination and sorting abstraction.
Interface to allow execution of Query by Example
Example instances.Interface to allow execution of QueryDsl
Predicate instances.Types managed by a Spring Data implementation.
BeanFactoryInitializationAotProcessor implementation used to encapsulate common data infrastructure concerns
and preprocess the ConfigurableListableBeanFactory ahead of the AOT compilation in order to prepare the
Spring Data BeanDefinitions for AOT processing.AuditableBeanWrapperFactory that will create am AuditableBeanWrapper using mapping information
obtained from a MappingContext to detect auditing configuration and eventually invoking setting the auditing
values.This interface defines the overall context including all known PersistentEntity instances and methods to obtain
instances on demand. it is used internally to establish associations between entities and also at runtime to obtain
entities by name.
Base implementation of an
ApplicationEvent refering to a PersistentEntity.TypeInformationMapper implementation that can be either set up using a MappingContext or manually set
up Map of String aliases to types.Exception being thrown in case an entity could not be instantiated in the process of a to-object-mapping.
SPI to create
MethodInterceptor instances based on the given source object and the target type to produce.API to record method invocations via method references on a proxy.
Interceptor enforcing required return value and method parameter constraints declared on repository query methods.
Strategy interface providing
predicates to resolve a method called on a composite to its
implementation method.Value object representing an invoked
Method.A method predicate to be applied on the
MethodLookup.InvokedMethod and method candidate.Deprecated.
since 3.0, use
MetadataReader directly to obtain declared methods directly.Deprecated.
since 3.0, use
MetadataReader to obtain declared
methods directly.Deprecated.
since 3.0.
Interface for
Metrics that can be applied to a base scale.Commonly used
Metrics.Interface capturing mutator methods for
PersistentEntitys.Abstraction of a map of
NamedQueries that can be looked up by their names.Builder to create a
BeanDefinition for a NamedQueries instance using properties.BeanDefinitionParser to create BeanDefinitions of NamedQueries instances looking up a
Properties file fom the given location.Annotation to exclude repository interfaces from being picked up and thus in consequence getting an instance being
created.
Utility methods to introspect nullability rules declared in packages, classes and methods.
Simple value object to wrap a nullable delegate.
Converters to wrap and unwrap nullable wrapper types potentially being available on the classpath.
A
ScrollPosition based on the offsets within query results.Utility methods to work with
Optionals.XmlAdapter to convert
Sort.Order instances into SpringDataJaxb.OrderDtos and vice versa.A page is a sublist of a list of objects.
Abstract interface for pagination information.
Argument resolver to extract a
Pageable object from a NativeWebRequest for a particular
MethodParameter.Annotation to set defaults when injecting a
Pageable into a controller
method.Support for query execution using
Pageable.Extracts paging information from web requests and thus allows injecting
Pageable instances into controller
methods.Callback interface that can be implemented by beans wishing to customize the
PageableHandlerMethodArgumentResolver configuration.Base class providing methods for handler method argument resolvers to create paging information from web requests and
thus allows injecting
Pageable instances into controller methods.HandlerMethodArgumentResolver to allow injection of PagedResourcesAssembler into Spring MVC
controller methods.Basic
Page implementation.Basic Java Bean implementation of
Pageable.Repository fragment to provide methods to retrieve entities using the pagination and sorting abstraction.
A tuple of things.
Annotation to bind method parameters to a query via a named parameter.
Value object to represent constructor parameters.
Class to abstract a single parameter of a query method.
Interface to access method parameters.
Exception to be thrown when trying to access a
Parameter with an invalid index inside a Parameters
instance.Abstracts method parameters that have to be bound to query parameters or applied to the query independently.
ParameterAccessor implementation using a Parameters instance to find special parameters.Abstraction over a list of parameter value types.
Callback interface to lookup values for a given
Parameter.Utility methods for
BeanDefinitionParser implementations.Utility methods for
String parsing.A single part of a method name that has to be transformed into a query part.
The various types of ignore case that are supported.
The type of a method name part.
Class to parse a
String into a tree or PartTree.OrParts consisting of simple Part instances in turn.A part of the parsed source that results from splitting up the resource around Or keywords.
Simple interface for entities.
IsNewStrategy that invokes Persistable.isNew() on the given object.Deprecated.
in favor of
PersistenceCreator since 3.0, to be removed in 3.1Marker annotation to declare a constructor or factory method annotation as factory/preferred constructor annotation.
RepositoryProxyPostProcessor to register a PersistenceExceptionTranslationInterceptor on the
repository proxy.Annotation to generally identify persistent types, fields and parameters.
Value object to access
PersistentEntity instances managed by MappingContexts.Factory been to create
PersistentEntities from a MappingContext.Represents a persistent entity.
EntityInformation implementation that uses a PersistentEntity to obtain id type information and uses
a IdentifierAccessor to access the property value if requested.ParameterValueProvider based on a PersistentEntity to use a PropertyValueProvider to lookup
the value of the property referenced by the given Parameter.Domain service to allow accessing and setting
PersistentPropertys of an entity.Factory to create
PersistentPropertyAccessor for a given PersistentEntity and bean instance.Abstraction of a path of
PersistentPropertys.Extension of
PersistentPropertyAccessor that is also able to obtain and set values for
PersistentPropertyPaths.A wrapper for a collection of
PersistentPropertyPaths.Represents a geospatial point value.
Converter to parse two comma-separated doubles into a
Point.Simple value object to represent a
Polygon.Utility methods to work with
Predicates.Value object to encapsulate the constructor to be used when mapping persistent data to objects.
Helper class to find a
PreferredConstructor.Helper class to find a
PreferredConstructor.Annotation to mark projection interfaces that are supposed to be used as projection interface to bind request or
response payloads to.
Configuration class to register a
BeanPostProcessor to augment RequestMappingHandlerAdapter with a
ProxyingHandlerMethodArgumentResolver.HttpMessageConverter implementation to enable projected JSON binding to interfaces annotated with
ProjectedPayload.A factory to create projecting instances for other objects usually used to allow easy creation of representation
projections to define which properties of a domain objects shall be exported in which way.
Information about a projection type.
NamedQueries implementation backed by a Properties instance.Factory bean to create
PropertiesBasedNamedQueries.Value object to abstract the concept of a property backed by a
Field and / or a PropertyDescriptor.Callback interface to do something with all plain
PersistentProperty instances except associations
and transient properties.FieldNamingStrategy simply using the PersistentProperty's name.Abstraction of a
PropertyPath of a domain class.Exception being thrown when creating
PropertyPath instances.PropertyValueConversions provides access to converters that may only be
applied to a specific property.Conversion service based on
CustomConversions used to convert domain and store values using
property-specific converters.PropertyValueConverter provides a symmetric way of converting certain properties from domain to
store-specific values.A
PropertyValueConverter that delegates conversion to the given BiFunctions.No-op
PropertyValueConverter implementation.A factory providing
value converters.Configuration class used to register a
PropertyValueConverter with
a SimplePropertyValueConverterRegistry that can be used in PropertyValueConversions.PropertyValueConverterRegistrar.ReadingConverterRegistrationBuilder<T,S,R,P extends PersistentProperty<P>>
Helper class used to build a fluent API to register how to read a database value into a domain object property.
PropertyValueConverterRegistrar.WritingConverterRegistrationBuilder<T,S,P extends PersistentProperty<P>>
Helper class used to build up a fluent registration API starting with writing.
SPI for components to provide values for as
PersistentProperty.HandlerMethodArgumentResolver to create Proxy instances for interface based controller method parameters.Proxy type detection utilities, extensible via
ProxyUtils.ProxyDetector registered via Spring factories.SPI to extend Spring's default proxy detection capabilities.
Basic Java Bean implementation of
Pageable with support for QueryDSL.Sort option for queries that wraps a Querydsl
OrderSpecifier.Meta-Annotation to mark a store specific annotation as a query annotation.
Interface to allow execution of Query by Example
Example instances.Exception to be thrown if a query cannot be created from a
Method.Callback for listeners that want to execute functionality on
RepositoryQuery creation.QuerydslBinderCustomizer<T extends com.querydsl.core.types.EntityPath<?>>
A component that will customize
QuerydslBindings for the given entity path.A component for
QuerydslBindings customization acting as default customizer the given entity path regardless
of the domain type.QuerydslBindings allows definition of path specific bindings.Factory to create
QuerydslBindings using an EntityPathResolver.Annotation to customize the binding of HTTP request parameters to a Querydsl
Predicate in Spring MVC handler methods.HandlerMethodArgumentResolver to allow injection of Predicate into Spring MVC
controller methods.HandlerMethodArgumentResolver to allow injection of Predicate into Spring MVC
controller methods.Builder assembling
Predicate out of PropertyValues.Interface to allow execution of QueryDsl
Predicate instances.RepositoryInvoker that is aware of a QuerydslPredicateExecutor and Predicate to be executed
for all flavors of findAll(…).Utility class for Querydsl.
Querydsl-specific web configuration for Spring Data.
Converters to potentially wrap the execution of a repository method into a variety of wrapper types potentially being
available on the classpath.
Strategy interface for which way to lookup
RepositoryQuerys.Abstraction of a method that is designated to execute a finder query.
Provides a way to access a centrally defined potentially shared
EvaluationContext.Exception to represent a failed attempt to convert a source value into a query method parameter.
Simple value object to work with ranges and boundaries.
Value object representing a boundary.
Builder for
Range allowing to specify the upper boundary.Auditing handler to mark entity objects created and modified.
Interface for components that are aware of the application's current auditor.
Interface for generic CRUD operations on a repository for a specific type.
Interface to be implemented by objects that can manage a number of
EntityCallback objects and invoke these
with a specific entity.SPI to resolve a
EvaluationContextExtension to make it accessible via the root of an
EvaluationContext provided by a
ExtensionAwareQueryMethodEvaluationContextProvider.Provides a way to access a centrally defined potentially shared
EvaluationContext.A reactive
EvaluationContextProvider that assembles an EvaluationContext from a list of
ReactiveEvaluationContextExtension and EvaluationContextExtension instances.An reactive
QueryMethodEvaluationContextProvider that assembles an EvaluationContext from a list of
EvaluationContextExtension and ReactiveEvaluationContextExtension.AuditingHandler extension that uses PersistentEntity.isNew(Object) to expose a generic
ReactiveIsNewAwareAuditingHandler.markAudited(Object) method that will route calls to ReactiveAuditingHandler.markCreated(Object) or
ReactiveAuditingHandler.markModified(Object) based on the IsNewStrategy determined from the factory.Extracts paging information from web requests and thus allows injecting
Pageable instances into WebFlux
controller methods.Interface to allow execution of Query by Example
Example instances using a reactive infrastructure.HandlerMethodArgumentResolver to allow injection of Predicate into Spring
WebFlux controller methods.Interface to issue queries using Querydsl
Predicate instances.Querydsl-specific web configuration for Spring Data.
Provides a way to access a centrally defined potentially shared
EvaluationContext by considering
ReactiveEvaluationContextExtension.Base class for repository factories to use reactive support.
Reactive
HandlerMethodArgumentResolver to create Sort instances from query string parameters or
SortDefault annotations.Repository fragment to provide methods to retrieve entities using the sorting abstraction.
Conversion support for reactive wrapper types.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.0, use
ReactiveWrappers instead as the utility was moved
into the org.springframework.data.util package.Utility class to expose details about reactive wrapper types.
Deprecated, for removal: This API element is subject to removal in a future version.
use
ReactiveWrappers.ReactiveLibrary instead.Enumeration of supported reactive libraries.
Annotation to clarify intended usage of a
Converter as reading converter in case the conversion types leave
room for disambiguation.Marks a field to be read-only for the mapping framework and therefore will not be persisted.
Meta-annotation to be used to annotate annotations that mark references to other objects.
Spring Data specific reflection utility methods and classes.
A
ReflectionUtils.FieldFilter for a given annotation.A
ReflectionUtils.FieldFilter that has a description.Extension to
BeanRegistrationAotContribution that bases its contribution on a RegisteredBean.Wrapper class to access repository instances obtained from a
ListableBeanFactory.ApplicationEvent being thrown after a RepositoryPopulator has finished populating the
Repositories available in the ApplicationContext.Central repository marker interface.
Base class to implement repository namespaces.
Base class to implement
ImportBeanDefinitionRegistrars to enable repositoryComposite implementation to back repository method implementations.
Value object representing an ordered list of
fragments.Configuration information for a single repository instance.
Delegate for configuration integration to reuse the general way of detecting repositories.
SPI to implement store specific extension to the repository bean definition registration process.
Base implementation of
RepositoryConfigurationExtension to ease the implementation of the interface.Interface containing the configurable options for the Spring Data repository subsystem.
Base class to implement
RepositoryConfigurationSources.Helper class to centralize common functionality that needs to be used in various places of the configuration
implementation.
Exception thrown in the context of repository creation.
Annotation to demarcate interfaces a repository proxy shall be created for.
Adapter for Springs
FactoryBean interface to allow easy setup of repository factories via Spring
configuration.Callback interface that can be used to to customize a
repository factory.Interface for components that can provide meta-information about a repository factory, the backing
EntityInformation and RepositoryInformation as well as the QueryMethods exposed by the
repository.Factory bean to create instances of a given repository interface.
Value object representing a repository fragment.
Fragment configuration consisting of an interface name and the implementation class name.
Interface exposing
RepositoryFragmentConfiguration.Factory bean for creation of
RepositoryComposition.RepositoryFragments.Additional repository specific information
Common base class for
RepositoryInformation that delays resolution of RepositoryMetadata and the
repository base to the latest possible time.Meta-information about the methods a repository exposes.
API to invoke (CRUD) methods on Spring Data repository instances independently of the base interface they expose.
Interface for a factory to create
RepositoryInvoker instances for repositories managing a particular domain
type.Metadata for repository interfaces.
Interface to be implemented by listeners that want to be notified upon repository method invocation.
Value object capturing the actual invocation.
NamespaceHandler to register BeanDefinitionParsers for repository initializers.Interface for components that will populate the Spring Data repositories with objects.
Callback interface used during repository proxy creation.
Interface for a query abstraction.
BeanRegistrationAotContribution used to contribute repository registrations.BeanRegistrationAotProcessor responsible processing and providing AOT configuration for repositories.BeanDefinitionParser to parse repository initializers.A
ResultProcessor to expose metadata about query result element projection and eventually post processing raw
query results into projections and data transfer objects.A representation of the type returned by a
QueryMethod.Wrapper to contain
RevisionMetadata as well as the revisioned entity.Information about a revision entity which is the class carrying revision information for an entity.
Metadata about a revision.
The type of a
Revision.A repository which can access entities held in a variety of
Revisions.A dedicated
Sort implementation that allows the definition of the ordering of revisions independently of the
property name the revision number is held in.Interface for generic CRUD operations on a repository for a specific type.
Repository fragment to provide methods to retrieve entities using the sorting abstraction.
Interface to specify a position within a total query result.
Keyset scrolling direction.
Common interface for all shapes.
Association handler to work with the untyped
PersistentProperty based Association.Simple implementation of
EntityPathResolver to lookup a query class by reflection and using the static field
of the same type.A property handler to work with untyped
PersistentProperty instances.PropertyValueConversions implementation allowing a PropertyValueConverterFactory creating
converters to be chosen.A registry of property specific
value convertes that may be used to convert only
specific properties/values of an object.Simple container to hold a set of types to be considered simple types.
Basic
TypeInformationMapper implementation that interprets the alias handles as fully qualified class name
and tries to load a class with the given name to build TypeInformation.A slice of data that indicates whether there's a next or previous slice available.
HandlerMethodArgumentResolver to allow injection of SlicedResourcesAssembler into Spring MVC
controller methods.Default implementation of
Slice.FieldNamingStrategy that translates typical camel case Java property names to lower case JSON element names,
separated by underscores.Sort option for queries.
Enumeration for sort directions.
Enumeration for null handling hints that can be used in
Sort.Order expressions.PropertyPath implements the pairing of an
Sort.Direction and a property.Extension of Sort to use method handles to define properties to sort by.
Argument resolver to extract a
Sort object from a NativeWebRequest for a particular
MethodParameter.Wrapper annotation to allow declaring multiple
SortDefault annotations on a method parameter.HandlerMethodArgumentResolver to automatically create Sort instances from request parameters or
SortDefault annotations.Callback interface that can be implemented by beans wishing to customize the
SortHandlerMethodArgumentResolver configuration.Base class providing methods for handler method argument resolvers to create
Sort instances from request
parameters or SortDefault annotations.A
ProxyProjectionFactory that adds support to use Value-annotated methods on a projection interface
to evaluate the contained SpEL expression to define the outcome of the method call.Simple factory to create
SpelExpressionParser and EvaluationContext instances.Evaluates SpEL expressions as extracted by the
SpelQueryContext.SpelExtractor based on parameter information from a method and
parameter values from a method call.SPI for components that can evaluate Spring EL expressions.
ParameterValueProvider that can be used to front a ParameterValueProvider delegate to prefer a SpEL
expression evaluation over directly resolving the parameter value with the delegate.A SpelQueryContext is able to find SpEL expressions in a query string and to replace them with bind
variables.
An extension of
SpelQueryContext that can create SpelEvaluator instances as it also knows about a
QueryMethodEvaluationContextProvider.JavaConfig class to export Jackson specific configuration.
Marker interface to describe configuration classes that ship Jackson modules that are supposed to be added to the
Jackson
ObjectMapper configured for EnableSpringDataWebSupport.Helper class containing utility methods to implement JAXB
XmlAdapters as well as the DTO types to be
marshalled by JAXB.The DTO for
Sort.Order.The DTO for
Page.The DTO for
Pageables/PageRequests.The DTO for
Sort.Configuration class to register
PageableHandlerMethodArgumentResolver,
SortHandlerMethodArgumentResolver and DomainClassConverter.Simple interface to ease streamability of
Iterables.Spring Data specific Java
Stream utility methods and classes.MethodInterceptor detecting whether a transaction is already running and exposing that fact via
SurroundingTransactionDetectorMethodInterceptor.isSurroundingTransactionActive().Extension of
TargetClassAware to be able to ignore the getter on JSON rendering.IdentifierAccessor that is aware of the target bean to obtain the identifier from so that it can generate a
more meaningful exception in case of an absent identifier and a call to TargetAwareIdentifierAccessor.getRequiredIdentifier().Extension of
RepositoryFactoryBeanSupport to add transactional capabilities to the repository proxy.Marks a field to be transient for the mapping framework.
Simple constants holder.
Annotation to allow
String based type aliases to be used when writing type information for
PersistentEntitys.Interface to abstract implementations of how to access a type alias from a given source or sink.
Collector to inspect domain types and discover the type graph that is relevant for Spring Data operations.
Parser to populate the given
ClassPathScanningCandidateComponentProvider with TypeFilters parsed from
the given Element's children.Interface to access property types and resolving generics on the way.
Interface to abstract the mapping from a type alias to the actual type.
Interface to define strategies how to store type information in a store specific sink or source.
A scanner that searches the classpath for matching types within given target packages.
Exception thrown during repository creation when a well-known fragment interface is not supported by the repository
factory.
The
ValueConversionContext provides access to the store-specific PersistentProperty and allows to
call the store-default conversion through the read/write methods.Annotation to define usage of a
PropertyValueConverter to read/write the property.A registry of
property-specific value converters
to convert only specific properties/values of an object.Demarcates a property to be used as version field to implement optimistic locking on entities.
Value object to represent a Version consisting of major, minor and bugfix part.
A set of data consumed from an underlying query result.
An
Iterator over multiple Windows obtained via a window function, that keeps
track of the current ScrollPosition allowing scrolling across all result elements.Builder API to construct a
WindowIterator.Annotation to clarify intended usage of a
Converter as writing converter in case the conversion types leave
room for disambiguation.A read-only
HttpMessageConverter to create XMLBeam-based projection instances for interfaces.XML based
RepositoryConfigurationSource.