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.
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.
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.
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 create Distance instances from String representations.
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.
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.
Custom Page to carry the average distance retrieved from the GeoResults the GeoPage is set up from.
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.
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.
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.
Helper class to register JSR-310 specific Converter implementations.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A ScrollPosition based on the last seen key set.
BeanInfoFactory specific to Kotlin types using Kotlin reflection to determine bean properties.
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.
Limit represents the maximum value up to which an operation should continue processing.
 
 
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.
Lock provides more extensive locking operations than can be obtained using synchronized methods and Lock.
An acquired lock can be used with try-with-resources for easier releasing.
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.
MultiValueBinding<T extends com.querydsl.core.types.Path<? extends S>,S>
MultiValueBinding creates a Predicate out of given Path and collection value.
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.
Argument resolver to extract a OffsetScrollPosition object from a NativeWebRequest for a particular MethodParameter.
HandlerMethodArgumentResolver to automatically create OffsetScrollPosition instances from request parameters.
Callback interface that can be implemented by beans wishing to customize the OffsetScrollPositionHandlerMethodArgumentResolver configuration.
Base class providing methods for handler method argument resolvers to create OffsetScrollPosition instances from request parameters.
Utility methods to work with Optionals.
OptionalValueBinding<T extends com.querydsl.core.types.Path<? extends S>,S>
OptionalValueBinding creates a Predicate out of given Path and value.
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.
XmlAdapter to convert Page instances into SpringDataJaxb.PageDto instances and vice versa.
RepresentationModelAssembler to easily convert Page instances into PagedModel.
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.
Parameters<S extends Parameters<S,T>,T extends Parameter>
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.1
Marker annotation to declare a constructor or factory method annotation as factory/preferred constructor annotation.
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.
Helper class used to build a fluent API to register how to read a database value into a domain object property.
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.
Reactive HandlerMethodArgumentResolver to create OffsetScrollPosition instances from query string parameters.
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.
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.
A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing.
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 repository
Composite 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.
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.
 
 
A RepositoryPopulator using a ResourceReader to read objects from the configured Resources.
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.
Simple wrapper class for a List of Revisions allowing to canonically access the latest revision.
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.
SingleValueBinding<T extends com.querydsl.core.types.Path<? extends S>,S>
SingleValueBinding creates a Predicate out of given Path and value.
A slice of data that indicates whether there's a next or previous slice available.
RepresentationModelAssembler to easily convert Slice instances into SlicedModel.
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.
XmlAdapter to convert Sort instances into SpringDataJaxb.SortDto instances and vice versa.
Argument resolver to extract a Sort object from a NativeWebRequest for a particular MethodParameter.
Annotation to define the default Sort options to be used when injecting a Sort instance into a controller handler method.
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.
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.