|
Spring Data Commons | |||||||||
| 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.PersistentEntitys.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
.
Bean wrappers.CdiRepositoryBean.
Extension implementations that create instances for Spring Data repositories.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.
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.
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.
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 CrudRepository, 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.PersistentEntities.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.
Predicate.
Revisions of an entity with the given id.
Page of revisions for the entity with the given id.
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.
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.
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.
EntityManager.
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.
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.
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.
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.
EntityInformation 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.
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.
PropertyPath.
Parameters was created for contains a Pageable argument.
Method has a parameter of the given type.
PreferredConstructor.Parameters.
Parameters was created for contains a Sort argument.
Pageable, Sort).
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 MappedConstructor.
PreferredConstructor.Parameter is one referring to an enclosing class.
PersistentProperty is actually to be regarded as PersistentEntity
in turn.
PersistenceConstructor).
Repository interface.
Id annotation found on it.
PersistentProperty is the id property of the entity.
PersistentEntity.
Map.
Map.
Param.
Persistable is new or was persisted already.
Page of results.
Transient, Value or Autowired as
transien.
FactoryBean to set up a ResourceReaderRepositoryPopulator with a JacksonResourceReader.ResourceReader using Jackson to read JSON into objects.JacksonResourceReader.
JacksonResourceReader using the given ObjectMapper.
ApplicationEvent refering to a PersistentEntity.MappingContextEvent for the given MappingContext and PersistentEntity.
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.
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.
PropertyPath.
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.Pageable instances into controller
methods.Pageable into a controller method.XmlAdapter to convert Page instances into SpringDataJaxb.PageDto instances and vice versa.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 type, Annotations, positioned at the given index inside the
given Parameters.
Parameter with an invalid index inside a Parameters
instance.ParameterOutOfBoundsException with the given exception as cause.
Parameters.
ParameterAccessor implementation using a Parameters instance to find special parameters.ParametersParameterAccessor.
PreferredConstructor.Parameter.TypeInformation implementations that need parent type awareness.ParentTypeAwareTypeInformation.
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.
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.
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 MappedConstructor to instantiate an
instance of the entity via reflection.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.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.
Pageable that is being used to back missing parameters.
Set of types to populate the context initially.
NamedQueries instance.
ObjectMapper to be used.
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.
DefaultSpELExpressionEvaluator to evaluate the SpEL Expression the PreferredConstructor.Parameter
potentially carries.
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.Order instance.
XmlAdapter to convert Sort instances into SpringDataJaxb.SortDto instances and vice versa.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.
XmlAdapters as well as the DTO types to be
marshalled by JAXB.Sort.Order.Page.Pageables/PageRequests.Sort.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.
Sort.
RepositoryFactoryBeanSupport to add transactional capabilities to the repository proxy.String based type aliases to be used when writing type information for
PersistentEntitys.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 Commons | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||