|
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.
FactoryBeans creating ResourceReaderRepositoryPopulators.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.
RepositoryProxyPostProcessors to the factory to allow manipulation of the ProxyFactory before
the proxy gets created.
Sort consisting of the Sort.Orders 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.
Associations.Association between the two given PersistentPropertys.
Associations.BeanDefinitionParser that parses an AuditingHandler BeanDefinitionPersistentEntitys.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 PlatformTransactionManagers.
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.Parameters 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 TypeInformationMappers.
EntityInformations 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.
PropertyEditors for domain classes.Association.
AssociationHandler to all Association contained in this PersistentEntity.
PropertyHandler to all PersistentPropertys 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.PersistentEntitys.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 OrderSpecifiers.
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
Elements id attribute for a name.
Collection.
Collections or the key type for Maps.
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.
TypeFilters 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.
TypeFilters 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.
Methods parameters.
PropertyPath.
Pageable of the parameters, if available.
Pageable Method parameter if available.
Pageable information in.
PreferredConstructor.Parameters of the constructor.
Parameters instance backing the accessor.
Parameters wrapper to gain additional information about Method parameters.
TypeInformations for the parameters of the given Constructor.
TypeInformations 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.OrParts of the PartTree of the given Part.Type.
PreferredConstructor to be used to instantiate objects of this PersistentEntity.
PersistentEntitys 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.
PersistentPropertys 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.
QueryMethods declared for that repository.
QueryMethods contained in the repository managing the given domain class.
Repositories that were populated.
RepositoryConfiguration instance for the given RepositoryConfigurationSource and
interface name.
RepositoryConfigurations 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.Parameters.
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.
PersistentEntitys.NamedQueries that can be looked up by their names.BeanDefinition for a NamedQueries instance.NamedQueriesBeanDefinitionBuilder using the given default location.
BeanDefinitionParser to create BeanDefinitions 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.OrderDtos 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 Parameters 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.OrParts 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.
PersistentPropertys.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.Parameters.
PreferredConstructor.Parameter with the given name, TypeInformation as well as an array of
Annotations.
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.RepositoryQuerys.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.
ImportBeanDefinitionRegistrars to enable repositoryBeanNameGenerator to create bean names for Spring Data repositories.RepositoryConfigurationExtension to ease the implementation of the interface.RepositoryConfigurationSources.RepositoryConfigurationSourceSupport with the given environment.
FactoryBean interface to allow easy setup of repository factories via Spring
configuration.EntityInformation and RepositoryInformation as well as the QueryMethods 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 BeanDefinitionParsers 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 Resources.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.
Resources to be used to initialize the repositories.
Resources to be used to load objects from and initialize the repositories eventually.
Resources 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
MappingExceptions 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.Orders.
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.
XmlAdapters as well as the DTO types to be
marshalled by JAXB.Sort.Order.Page.Pageables/PageRequests.Sort.PageableHandlerMethodArgumentResolver,
SortHandlerMethodArgumentResolver and DomainClassConverter.PersistentProperty.getName().
Converter to translate individual
PersistentPropertys 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
PersistentEntitys.ClassPathScanningCandidateComponentProvider with TypeFilters 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 | |||||||||