|
Spring Data Core | |||||||||
PREV NEXT | FRAMES NO FRAMES |
EntityInformation
.AbstractEntityInformation
from the given domain class.
PersistentEntity
and
PersistentProperty
.PersistentProperty
.PartTree
.AbstractQueryCreator
for the given PartTree
and ParametersParameterAccessor
.
AbstractQueryCreator
for the given PartTree
.
RepositoryMetadata
implementations.AbstractRepositoryMetadata
.
FactoryBean
s creating ResourceReaderRepositoryPopulator
s.Association
to the entity.
MappingContext
.
TypeInformation
to the MappingContext
.
PersistentProperty
to the entity.
QueryCreationListener
to the factory to plug in functionality triggered right after creation of
RepositoryQuery
instances.
RepositoryProxyPostProcessor
s to the factory to allow manipulation of the ProxyFactory
before
the proxy gets created.
Sort
consisting of the Sort.Order
s of the current Sort
combined with the given
ones.
PersistentProperty
that takes annotations at a property into account.AnnotationBasedPersistentProperty
.
ReflectionUtils.FieldCallback
that will inspect each field for a given annotation.AnnotationDetectionFieldCallback
scanning for an annotation of the given type.
RepositoryConfigurationSource
.AnnotationRepositoryConfigurationSource
from the given AnnotationMetadata
and
annotation.
RepositoryMetadata
implementation inspecting the given repository interface for a
RepositoryDefinition
annotation.AnnotationRepositoryMetadata
instance looking up repository types from a
RepositoryDefinition
annotation.
RevisionMetadata
implementation that inspects the given object for fields with the configured annotations
and returns the field's values on calls to AnnotationRevisionMetadata.getRevisionDate()
and AnnotationRevisionMetadata.getRevisionNumber()
.AnnotationRevisionMetadata
inspecing the given entity for the given annotations.
Method
's return type to be one of the given types.
Association
s.Association
between the two given PersistentProperty
s.
Association
s.BeanDefinitionParser
that parses an AuditingHandler
BeanDefinition
PersistentEntity
s.BasicPersistentEntity
from the given TypeInformation
.
BasicPersistentEntity
for the given TypeInformation
and Comparator
.
BeanComponentDefinition
more easily.BeanComponentDefinitionBuilder
using the given Element
as default source and the
given ParserContext
.
BeanDefinition
from the given source.
BeanDefinitionBuilder
from the given BeanDefinitionRegistry
and ResourceLoader
.
IsNewStrategyFactory
that caches resolved IsNewStrategy
instances per type to avoid re-resolving them
on each and every request.CachingIsNewStrategyFactory
delegating to the given IsNewStrategyFactory
.
Bean
wrappers.CdiRepositoryBean
.
Extension
implementations that create instances for Spring Data repositories.PlatformTransactionManager
implementation that orchestrates transaction creation, commits and rollbacks to a
list of delegates.ChainedTransactionManager
delegating to the given PlatformTransactionManager
s.
TypeInformation
for a plain Class
.Sort
definition.
TypeInformationMapper
implementation that can be either set up using a MappingContext
or manually set
up Map
of String
aliases to types.ConfigurableTypeMapper
for the given type map.
Predicate
will return.
Sort.Sort(Direction, List)
instead.
BeanWrapper
for the given bean instance and ConversionService
.
QueryCreationException
.
QueryCreationException
for the given QueryMethod
and Throwable
as cause.
TypeInformation
.
Parameter
instance for the given MethodParameter
.
Parameters
instance.
EntityPath
instance for the given domain class.
PersistentEntity
instance.
PersistentProperty
.
Sort
parameter.
RepositoryFactorySupport
instance.
RepositoryFactorySupport
creation to TransactionalRepositoryFactoryBeanSupport.doCreateRepositoryFactory()
and applies the
TransactionalRepositoryProxyPostProcessor
to the created instance.
TypeFilter
instance from the given Element
and ClassLoader
.
DateTimeProvider
simply creating new DateTime
instances for each method call.DateTime
instance to be used when auditing.Parameters
.DefaultParameters
instance from the given Method
.
RepositoryConfiguration
.DefaultRepositoryConfiguration
from the given RepositoryConfigurationSource
and
interface name.
RepositoryMetadata
.DefaultRepositoryMetadata
for the given repository interface.
ParameterValueProvider
implementation that evaluates the PreferredConstructor.Parameter
s key against
SpelExpressionParser
and EvaluationContext
.MongoTypeMapper
allowing configuration of the key to lookup and store type
information in DBObject
.DefaultTypeMapper
using the given TypeAliasAccessor
.
DefaultTypeMapper
using the given TypeAliasAccessor
and TypeInformationMapper
s.
DefaultTypeMapper
using the given TypeAliasAccessor
, MappingContext
and
additional TypeInformationMapper
s.
EntityInformation
s and delegate execution of standard methods from
EntityInformation
to a special implementation.DelegatingEntityInformation
delegating method invocations to the given
EntityInformation
.
RepositoryFactorySupport
instance.
IsNewStrategy
to be used for the given type.
Converter
to convert arbitrary input into domain classes managed
by Spring Data CrudRepository
s.PropertyEditor
to map entities handled by a CrudRepository
to their id's and vice versa.DomainClassPropertyEditor
for the given repository, EntityInformation
and
PropertyEditorRegistry
.
PropertyEditor
s for domain classes.Association
.
AssociationHandler
to all Association
contained in this PersistentEntity
.
PropertyHandler
to all PersistentProperty
s contained in this
PersistentEntity
.
EntityReader
and EntityWriter
and add the ability to access a MappingContext
and
ConversionService
.EntityMetadata
to add functionality to query information of entity instances.PersistentEntity
s.EntityInstantiator
instances for a given type falling back to a
default one.EntityInstantiators
using the default fallback instantiator and no custom ones.
EntityInstantiators
using the given EntityInstantiator
as fallback.
EntityInstantiators
using the default fallback instantiator and the given custom ones.
EntityInstantiator
using the given fallback EntityInstantiator
and the given custom
ones.
EntityPath
.RepositoryQuery
with the given parameters.
Predicate
.
Predicate
applying the given OrderSpecifier
s.
Page
of entities matching the given Predicate
.
Page
of entities meeting the paging restriction provided in the Pageable
object.
AnnotationBasedPersistentProperty
.
ReflectionUtils.DescribedFieldFilter
.
ReflectionUtils.DescribedFieldFilter
.
ReflectionUtils.DescribedFieldFilter
.
Predicate
.
Revisions
of an entity with the given id.
Page
of revisions for the entity with the given id.
Pageable
requesting the first page.
Sort
instance into a List
of sort expressions, accumulating Sort.Order
instances
of the same direction into a single expression if they are in order.
PropertyPath
chain from the given source String
and type.
PropertyPath
chain from the given source String
and TypeInformation
.
ClassTypeInformation
.
Part.Type
of the Part
for the given raw propertyPath.
TypeInformation
from the given method's return type.
Sort.Direction
enum for the given String
value.
Sort.Direction
enum for the given String
or null if it cannot be parsed into an enum
value.
Map
value type if the type is a Map
, returns the
component type if the type TypeInformation.isCollectionLike()
or the simple type if none of this applies.
TypeInformation
.
AnnotationAttributes
of the annotation configured.
PersistentPropertyPath
.
PropertyPath
which could be resolved so far.
BeanNameGenerator
during classpath scanning.
Parameters
instance with effectively all special parameters removed.
BeanComponentDefinition
from the given BeanDefinitionBuilder
.
BeanComponentDefinition
from the given BeanDefinitionBuilder
using the given name.
BeanComponentDefinition
from the given BeanDefinitionBuilder
using the given name and
raw source object.
BeanComponentDefinition
from the given BeanDefinitionBuilder
and inspects the backing
Element
s id attribute for a name.
Collection
.
Collection
s or the key type for Map
s.
RepositoryConfigurationSource
that backs the RepositoryConfiguration
.
PreferredConstructor
.
Constructor
.
List
.
Revisions
instance.
ConversionService
used by the converter.
CrudMethods
meta information for the repository.
DateTime
to be used as modification date.
Bean
.
EntityInformation
the repository factory is using.
EntityInformation
for the given domain class.
EntityInformation
for the given domain class.
TypeFilter
s to define which types to exclude when scanning for repositories.
RepositoryConfigurationExtension
for store specific callbacks and BeanDefinition
post-processing.
TypeInformation
in case none could be extracted from the given source.
PersistentEntity
.
TypeFilter
s to define which types to include when scanning for repositories.
Parameters
.
EntityInstantiator
to be used to create the given PersistentEntity
.
IsNewStrategy
to be used for the given type.
Part.Type
.
PersistentPropertyPath
.
PropertyPath
.
PersistentPropertyPath
.
SpringDataJaxb.PageDto
.
MappingContext
used by the converter.
Map
.
Map
.
RevisionMetadata
for the current Revision
.
Param
annotation) or null if none can be found.
Method
s parameters.
PropertyPath
.
Pageable
of the parameters, if available.
Pageable
Method
parameter if available.
Pageable
information in.
PreferredConstructor.Parameter
s of the constructor.
Parameters
instance backing the accessor.
Parameters
wrapper to gain additional information about Method
parameters.
TypeInformation
s for the parameters of the given Constructor
.
TypeInformation
s for the parameters of the given Method
.
PreferredConstructor.Parameter
(usually when entity instances are created).
PersistentPropertyPath
, i.e. the path without the leaf property.
Iterable
of all parts contained in the PartTree
.
PartTree.OrPart
s of the PartTree
of the given Part.Type
.
PreferredConstructor
to be used to instantiate objects of this PersistentEntity
.
PersistentEntity
s held in the context.
PersistentEntity
for the given Class
.
PersistentEntity
for the given TypeInformation
.
PersistentEntity
mapped by the given PersistentProperty
.
PersistentEntity
the event was created for.
PersistentEntity
managed by the underlying repository.
PersistentEntity
for the given domain class.
TypeInformation
if the property references a PersistentEntity
.
PersistentProperty
instance by name.
PersistentProperty
s for the given path expression based on the given PropertyPath
.
PersistentProperty
of the underlying bean instance.
PersistentProperty
potentially converted to the given type.
PersistentProperty
.
QueryLookupStrategy
for the given QueryLookupStrategy.Key
.
QueryLookupStrategy
from eventually.
QueryLookupStrategy.Key
to define how query methods shall be resolved.
QueryMethod
s declared for that repository.
QueryMethod
s contained in the repository managing the given domain class.
Repositories
that were populated.
RepositoryConfiguration
instance for the given RepositoryConfigurationSource
and
interface name.
RepositoryConfiguration
s obtained through the given RepositoryConfigurationSource
.
FactoryBean
class to be used to create repository instances.
FactoryBean
to actually create repository instances.
RepositoryInformation
to determine meta-information about the repository being used.
RepositoryInformation
for the given repository interface.
RepositoryInformation
for the given domain class.
Method
.
TypeInformation
for the return type of the given Method
.
PropertyPath
.
Sort
specification parsed from the source or null.
Sort
Method
parameter if available.
RepositoryConfiguration
.
BeanDefinition
built by the given BeanDefinitionBuilder
enriched with source
information derived from the given Element
.
AbstractBeanDefinition
built by the given builder with the given extracted source applied.
Value
annotation at the property and returns the String
value of
it.
TypeInformation
for the given raw super type.
TypeInformation
of the parameter.
Iterable
or the value type of a Map
if the property is one.
Parameter
.
TypeInformation
for the type arguments of the current TypeInformation
.
TypeInformation
backing this PersistentEntity
.
TypeInformation
of the property.
PersistentEntity
.
BeanDefinitionRegistry
already contains a bean of the given type assuming the
bean name has been autogenerated.
BeanDefinitionRegistry
already contains a bean of the given type assuming the
bean name has been autogenerated.
Page
has content at all.
PersistentEntity
has an id property.
PropertyPath
.
Parameters
was created for contains a Pageable
argument.
Method
has a parameter of the given type.
PreferredConstructor.Parameter
s.
Pageable
we can access from the current one.
Parameters
was created for contains a Sort
argument.
Pageable
, Sort
).
PersistentEntity
has a version property.
PagedResourcesAssembler
and PagedResourcesAssemblerArgumentResolver
.PageableHandlerMethodArgumentResolver
that also supports enhancing URIs using Spring HATEOAS
support.HateoasSortHandlerMethodArgumentResolver
.
HateoasPageableHandlerMethodArgumentResolver
using the given
HateoasSortHandlerMethodArgumentResolver
..
SortHandlerMethodArgumentResolver
that also supports enhancing URIs using Spring HATEOAS
support.Sort.Order
with case insensitive sorting enabled.
CrudRepository.findOne(Serializable)
.
CrudRepository.save(Object)
.
TypeInformation
can be safely assigned to the given one.
Association
if it is annotated with Reference
.
Association
.
PersistentPropertyPath
is a base path of the current one.
Parameter
is to be bound to a query.
PropertyPath
is actually a collection.
Collection
, Iterable
or an array.
Collection
and Array
or anything implementing Iterable
.
PersistentProperty
is referred to by a constructor argument of the
PersistentEntity
.
PersistentProperty
is referenced in a constructor argument of the
PersistentEntity
backing this PreferredConstructor
.
PreferredConstructor.Parameter
is one referring to an enclosing class.
PersistentProperty
is actually to be regarded as PersistentEntity
in turn.
PersistenceConstructor
).
Repository
interface.
PersistentProperty
is the id property of the entity.
PersistentEntity
.
Map
.
Map
.
Param
.
Persistable
is new or was persisted already.
AuditingHandler
extension that uses an IsNewStrategyFactory
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.IsNewAwareAuditingHandler
using the given IsNewStrategyFactory
.
AuditingHandlerBeanDefinitionParser
that will register am IsNewAwareAuditingHandler
.IsNewAwareAuditingHandlerBeanDefinitionParser
.
IsNewStrategy
instances for a given class.IsNewStrategyFactory
that handles Persistable
implementations directly by retuning a
PersistableIsNewStrategy
and delegating to IsNewStrategyFactorySupport.doGetIsNewStrategy(Class)
for all other types.Page
of results.
Transient
, Value
or Autowired
as
transien.
PersistentProperty
is the version property of the entity.
PersistentEntity
.
FactoryBean
to set up a ResourceReaderRepositoryPopulator
with a Jackson2ResourceReader
.ResourceReader
using Jackson to read JSON into objects.Jackson2ResourceReader
.
Jackson2ResourceReader
using the given ObjectMapper
.
FactoryBean
to set up a ResourceReaderRepositoryPopulator
with a JacksonResourceReader
.ResourceReader
using Jackson to read JSON into objects.JacksonResourceReader
.
JacksonResourceReader
using the given ObjectMapper
.
JodaTimeConverters.LocalDateToDateConverter
implementations in case the library is present on the
classpath.Sort
instance into two expressions.
ApplicationEvent
refering to a PersistentEntity
.MappingContextEvent
for the given MappingContext
and PersistentEntity
.
IsNewStrategyFactory
using a MappingContext
to determine the IsNewStrategy
to be returned
for a particular type.MappingContextIsNewStrategyFactory
using the given MappingContext
.
TypeInformationMapper
implementation that can be either set up using a MappingContext
or manually set
up Map
of String
aliases to types.MappingContextTypeInformationMapper
from the given MappingContext
.
MappingInstantiationException.MappingInstantiationException(PersistentEntity, List, String, Exception)
instead.
MappingInstantiationException
for the given PersistentEntity
, constructor arguments
and the causing exception.
IsNewStrategy
returned by the
IsNewStrategyFactory
configured.
Iterable
using the given XmlAdapter
.
PersistentEntity
s.NamedQueries
that can be looked up by their names.BeanDefinition
for a NamedQueries
instance.NamedQueriesBeanDefinitionBuilder
using the given default location.
BeanDefinitionParser
to create BeanDefinition
s of NamedQueries
instances looking up a
Properties
file fom the given location.NamedQueriesBeanDefinitionParser
using the given default location.
Pageable
requesting the next Page
.
PropertyPath
.
Pageable
to request the next Page
.
RepositoryQuery
was created.
Sort.Order
instances into SpringDataJaxb.OrderDto
s and vice versa.Sort
instance from a method name end.OrderBySource
for the given String clause not doing any checks whether the referenced
property actually exists.
OrderBySource
for the given clause, checking the property referenced exists on the given
type.
Repository
abstraction.Repository
abstraction.PageableHandlerMethodArgumentResolver
instead.Pageable
into a controller
method.PageableDefault
instead.Pageable
instances into controller
methods.SortHandlerMethodArgumentResolver
.
SortHandlerMethodArgumentResolver
.
XmlAdapter
to convert Page
instances into SpringDataJaxb.PageDto
instances and vice versa.ResourceAssembler
to easily convert Page
instances into PagedResources
.PagedResourcesAssembler
using the given PageableHandlerMethodArgumentResolver
and
base URI.
HandlerMethodArgumentResolver
to allow injection of PagedResourcesAssembler
into Spring MVC
controller methods.PagedResourcesAssemblerArgumentResolver
using the given
PageableHandlerMethodArgumentResolver
and MethodLinkBuilderFactory
.
Page
implementation.PageImpl
.
PageImpl
with the given content.
Pageable
.PageRequest
.
PageRequest
with sort parameters applied.
PageRequest
with sort parameters applied.
CrudRepository
to provide additional methods to retrieve entities using the pagination and
sorting abstraction.Parameter
for the given MethodParameter
.
Parameter
with an invalid index inside a Parameters
instance.ParameterOutOfBoundsException
with the given exception as cause.
Parameters
.
Parameters
instance with the given Parameter
s put into new context.
ParameterAccessor
implementation using a Parameters
instance to find special parameters.ParametersParameterAccessor
.
PreferredConstructor.Parameter
.TypeInformation
implementations that need parent type awareness.ParentTypeAwareTypeInformation
.
TypeFilter
declared in nested elements of the given Element
.
BeanDefinitionParser
implementations.Part
from the given method name part, the Class
the part originates from and the
start parameter index.
Part
from the given method name part, the Class
the part originates from and the
start parameter index.
String
into a tree or PartTree.OrPart
s consisting of simple PartTree.OrPart
instances in turn.PartTree
by parsing the given String
.
EntityMetadata
that assumes the entity handled implements Persistable
and uses
Persistable.isNew()
for the AbstractEntityInformation.isNew(Object)
check.PersistableEntityInformation
.
IsNewStrategy
that invokes Persistable.isNew()
on the given object.RepositoryProxyPostProcessor
to register a PersistenceExceptionTranslationInterceptor
on the
repository proxy.PersistenceExceptionTranslationRepositoryProxyPostProcessor
using the given
ListableBeanFactory
.
ParameterValueProvider
based on a PersistentEntity
to use a PropertyValueProvider
to lookup
the value of the property referenced by the given PreferredConstructor.Parameter
.PersistentEntityParameterValueProvider
for the given PersistentEntity
and
PropertyValueProvider
.
PersistentProperty
s.Repositories
.
BeanDefinition
built from annotations and tweak the configuration if
necessary.
BeanDefinition
built from XML and tweak the configuration if necessary.
ProxyFactory
, e.g. add further interceptors to it.
Sort
parameter in the parameters.
PreferredConstructor
from the given Constructor
and PreferredConstructor.Parameter
s.
PreferredConstructor.Parameter
with the given name, TypeInformation
as well as an array of
Annotation
s.
PreferredConstructor
.PreferredConstructorDiscoverer
for the given type.
PreferredConstructorDiscoverer
for the given PersistentEntity
.
PreferredConstructorDiscoverer
for the given type.
Pageable
or the first Pageable
if the current one already is the first one.
Pageable
to request the previous page.
CdiRepositoryExtensionSupport.repositoryTypes
for later registration as bean type.
NamedQueries
implementation backed by a Properties
instance.PropertiesBasedNamedQueries
for the given Properties
instance.
PersistentProperty
instances except associations
and transient properties.PropertyPath
of a domain class.PropertyPath
instances.PropertyReferenceException
.
PersistentProperty
.QueryMethod
.RepositoryQuery
creation.Predicate
instances.RepositoryQuery
s.QueryMethod
from the given parameters.
Converter
as reading converter in case the conversion types leave
room for disambiguation.TypeInformation
from the given source.
TypeInformation
from the given source if it is a more concrete type than the given default one.
EntityInformation
implementation that inspects fields for an annotation and looks up this field's value to
retrieve the id.ReflectionEntityInformation
inspecting the given domain class for a field carrying the
Id
annotation.
ReflectionEntityInformation
inspecting the given domain class for a field carrying the given
annotation.
EntityInstantiator
that uses the PersistentEntity
's PreferredConstructor
to instantiate an
instance of the entity via reflection.ReflectionUtils.FieldFilter
for a given annotation.ReflectionUtils.AnnotationFieldFilter
for the given annotation type.
ReflectionUtils.FieldFilter
that has a description.AbstractBeanDefinition
and registers it inside the given
BeanDefinitionRegistry
.
ListableBeanFactory
.Repositories
instance by looking up the repository instances and meta information from the
given ListableBeanFactory
.
ApplicationEvent
being thrown after a RepositoryPopulator
has finished populating the
Repositories
available in the ApplicationContext
.RepositoriesPopulatedEvent
using the given RepositoryPopulator
and
Repositories
.
BeanDefinitionBuilder
instance to eventually create Spring Data repository instances.RepositoryBeanDefinitionBuilder
from the given RepositoryConfiguration
and
RepositoryConfigurationExtension
.
RepositoryBeanDefinitionParser
using the given RepositoryConfigurationExtension
.
ImportBeanDefinitionRegistrar
s to enable repositoryBeanNameGenerator
to create bean names for Spring Data repositories.RepositoryConfigurationExtension
to ease the implementation of the interface.RepositoryConfigurationSource
s.RepositoryConfigurationSourceSupport
with the given environment.
FactoryBean
interface to allow easy setup of repository factories via Spring
configuration.EntityInformation
and RepositoryInformation
as well as the QueryMethod
s exposed by the
repository.MethodInterceptor
intercepts calls to methods of the custom implementation and delegates the to it if
configured.RepositoryFactorySupport.QueryExecutorMethodInterceptor
.
NamespaceHandler
to register BeanDefinitionParser
s for repository initializers.RepositoryQuery
from the given QueryMethod
that can be executed afterwards.
TypeInformation
that shall be used when the given String
value is found as type hint.
TypeInformation
to be used for the given alias.
RepositoryPopulator
using a ResourceReader
to read objects from the configured Resource
s.ResourceReaderRepositoryPopulator
using the given ResourceReader
.
ResourceReaderRepositoryPopulator
using the given ResourceReader
and
ClassLoader
.
BeanDefinitionParser
to parse repository initializers.Revisions
.
RevisionMetadata
as well as the revisioned entity.Revision
consisting of the given RevisionMetadata
and entity.
Revisions
.List
of Revisions
allowing to canonically access the latest revision.Revisions
instance containing the given revisions.
AuditorAware
component to retrieve the current auditor.
Auditable.setCreatedDate(DateTime)
and
Auditable.setLastModifiedDate(DateTime)
shall be filled with the current Java time.
DateTimeProvider
to be used to determine the dates to be set.
Pageable
that is being used to back missing parameters.
Pageable
to be used as fallback in case no PageableDefault
or
PageableDefaults
(the latter only supported in legacy mode) can be found at the method parameter to be
resolved.
Sort
to be used as fallback in case no SortDefault
or SortDefault.SortDefaults
(the
latter only supported in legacy mode) can be found at the method parameter to be resolved.
Set
of types to populate the context initially.
NamedQueries
instance.
ObjectMapper
to be used.
ObjectMapper
to be used.
MappingContext
to be used to lookup PersistentEntity
instances for
RepositoryFactoryBeanSupport.getPersistentEntity()
.
NamedQueries
instance.
NamedQueries
instance to be handed to the QueryLookupStrategy
for query creation.
PersistentProperty
to the given value.
PersistentProperty
to the given value.
Element
if the attribute is configured.
BeanDefinitionBuilder
to the value of the
attribute with the given name if the attribute is configured.
QueryLookupStrategy.Key
to be used.
Resource
s to be used to initialize the repositories.
Resource
s to be used to load objects from and initialize the repositories eventually.
Resource
s to be used to initialize the repositories.
SimpleTypeHolder
to be used by the MappingContext
.
MappingContext
is in strict mode which means, that it will throw
MappingException
s in case one tries to lookup a PersistentEntity
not already in the context.
Unmarshaller
to be used.
PersistentEntity
instance should be created for the given TypeInformation
.
PropertyPath
referenced should be matched ignoring case.
EntityPathResolver
to lookup a query class by reflection and using the static field
of the same type.SimpleTypeHolder
containing the default types.
SimpleTypeHolder
to carry the given custom simple types.
SimpleTypeHolder
that carries the given additional custom simple types.
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
.Sort
instance using the given Sort.Order
s.
Sort
instance.
Sort
instance.
Sort
instance.
Sort
instance.
Sort.Direction
and a property.Sort.Order
instance. if order is null then order defaults to
Sort.DEFAULT_DIRECTION
Sort.Order
instance.
XmlAdapter
to convert Sort
instances into SpringDataJaxb.SortDto
instances and vice versa.Sort
options to be used when injecting a Sort
instance into a
controller handler method.SortDefault
annotations on a method parameter.HandlerMethodArgumentResolver
to automatically create Sort
instances from request parameters or
SortDefault
annotations.SpelExpressionParser
and EvaluationContext
instances.SpELContext
with the given PropertyAccessor
.
SpELContext
using the given SpelExpressionParser
and PropertyAccessor
.
SpELContext
using the given one's PropertyAccessor
and
SpelExpressionParser
as well as the given BeanFactory
.
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.SpELExpressionParameterValueProvider
using the given SpELExpressionEvaluator
,
ConversionService
and ParameterValueProvider
delegate to forward calls to, that resolve parameters
that do not have a Spel expression configured with them.
XmlAdapter
s as well as the DTO types to be
marshalled by JAXB.Sort.Order
.Page
.Pageable
s/PageRequest
s.Sort
.PageableHandlerMethodArgumentResolver
,
SortHandlerMethodArgumentResolver
and DomainClassConverter
.PersistentProperty.getName()
.
Converter
to translate individual
PersistentProperty
s to path segments.
PropertyPath
in dot notation.
String
path with the given delimiter based on the PersistentProperty.getName()
.
String
path with the given delimiter using the given Converter
for
PersistentProperty
to String conversion.
PagedResources
by converting the given Page
into a PagedResources.PageMetadata
instance and
wrapping the contained elements into Resource
instances.
PagedResources
by converting the given Page
into a PagedResources.PageMetadata
instance and
using the given ResourceAssembler
to turn elements of the Page
into resources.
PagedResources
by converting the given Page
into a PagedResources.PageMetadata
instance and
using the given ResourceAssembler
to turn elements of the Page
into resources.
Sort
.
RepositoryFactoryBeanSupport
to add transactional capabilities to the repository proxy.String
based type aliases to be used when writing type information for
PersistentEntity
s.ClassPathScanningCandidateComponentProvider
with TypeFilter
s parsed from
the given Element
's children.TypeFilterParser
with the given ReaderContext
.
Collection
using the given XmlAdapter
.
FactoryBean
to create a ResourceReaderRepositoryPopulator
using an Unmarshaller
.UserCredentials
instance from the given username and password.
PersistentEntity
.
MappingContextEvent
was triggered by the given MappingContext
.
Sort.Order
with the given Sort.Order
.
Sort
instance for the given properties.
TypeInformation
into the given sink.
Converter
as writing converter in case the conversion types leave
room for disambiguation.RepositoryConfigurationSource
.XmlRepositoryConfigurationSource
using the given Element
and ParserContext
.
|
Spring Data Core | |||||||||
PREV NEXT | FRAMES NO FRAMES |