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
FactoryBean
s creating ResourceReaderRepositoryPopulator
s.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
Association
s.Callback interface to implement functionality to be applied to a collection of
Association
s.Interface for auditable entities.
Interface to abstract the ways setting the auditing information can be implemented.
A factory to lookup
AuditableBeanWrapper
s.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
PersistentEntity
s.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
Factory to create a ValueExpressionEvaluator
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
Metric
s 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
.Deprecated.
since 3.3, use
CachingValueExpressionEvaluatorFactory
instead.Default implementation of
TypeMapper
.Useful base class to implement custom
EntityInformation
s 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 CrudRepository
s.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.
Registers a bean definition for
SpringDataWebSettings
carrying the configuration values of
EnableSpringDataWebSupport
.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
PersistentEntity
s.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
GeoResult
s 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 PersistentPropertyAccessor
s 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.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
Metric
s that can be applied to a base scale.Commonly used
Metric
s.Interface capturing mutator methods for
PersistentEntity
s.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 BeanDefinition
s 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
Optional
s.XmlAdapter to convert
Sort.Order
instances into SpringDataJaxb.OrderDto
s 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.DTO to build stable JSON representations of a Spring Data
Page
.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.Interface providing access to the method, containing class and domain type as source object for parameter
descriptors.
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.OrPart
s 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 MappingContext
s.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
PersistentProperty
s of an entity.Factory to create
PersistentPropertyAccessor
for a given PersistentEntity
and bean instance.Abstraction of a path of
PersistentProperty
s.Extension of
PersistentPropertyAccessor
that is also able to obtain and set values for
PersistentPropertyPath
s.A wrapper for a collection of
PersistentPropertyPath
s.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
Predicate
s.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 BiFunction
s.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
RepositoryQuery
s.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.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.
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.
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
ImportBeanDefinitionRegistrar
s 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
RepositoryConfigurationSource
s.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 Spring's
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 QueryMethod
s 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 BeanDefinitionParser
s 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.Deprecated.
Deprecated.
since 3.3, use
ValueExpressionParameterValueProvider
instead.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.
A Jackson module customizing the serialization of
PageImpl
instances depending on the
SpringDataWebSettings
handed into the instance.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
XmlAdapter
s as well as the DTO types to be
marshalled by JAXB.The DTO for
Sort.Order
.The DTO for
Page
.The DTO for
Pageable
s/PageRequest
s.The DTO for
Sort
.Configuration class to register
PageableHandlerMethodArgumentResolver
,
SortHandlerMethodArgumentResolver
, OffsetScrollPositionHandlerMethodArgumentResolver
and DomainClassConverter
.All Spring Data web-related settings (usually via
EnableSpringDataWebSupport
).Simple interface to ease streamability of
Iterable
s.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
PersistentEntity
s.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 TypeFilter
s 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.Expressions are executed in an evaluation context.
SPI to provide to access a centrally defined potentially shared
ValueEvaluationContext
.An expression capable of evaluating itself against context objects.
SPI for components that can evaluate Value 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.Parses expression strings into expressions that can be evaluated.
Configuration for
ValueExpressionParser
.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
.