|
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.
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.
RepositoryMetadata implementation inspecting the given repository interface for a
RepositoryDefinition annotation.AnnotationRepositoryMetadata instance looking up repository types from a
RepositoryDefinition annotation.
Method's return type to be one of the given types.
Associations.Association between the two given PersistentPropertys.
Associations.SingleRepositoryConfigInformation implementation that is not backed by an XML element but by a scanned
interface.AutomaticRepositoryConfigInformation for the given interface name and
CommonRepositoryConfigInformation parent.
PersistentEntitys.BasicPersistentEntity from the given TypeInformation.
BasicPersistentEntity for the given TypeInformation and Comparator.
Bean wrappers.CdiRepositoryBean.
Extension implementations that create instances for Spring Data repositories.TypeInformation for a plain Class.ClassTypeInformation for the given type.
Sort definition.
TypeInformationMapper implementation that can be either set up using a MappingContext or manually set
up Map of String aliases to types.ConfigurableTypeInformationMapper from the given MappingContext.
ConfigurableTypeMapper for the given type map.
Predicate will return.
BeanWrapper for the given bean instance and ConversionService.
BeanWrapper using the given PersistentEntity and ParameterValueProvider.
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.
SingleRepositoryConfigInformation for the given Element.
RepositoryMetadata.DefaultRepositoryMetadata for the given repository interface.
MongoTypeMapper allowing configuration of the key to lookup and store type
information in DBObject.RepositoryFactorySupport instance.
Converter to convert arbitrary input into domain classes managed
by Spring Data CrudRepository s.DomainClassConverter.
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.
EntityMetadata to add functionality to query information of entity instances.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.
PropertyPath chain from the given source String and type.
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.
PersistentPropertyPath.
Parameters instance with effectively all special parameters removed.
Collection.
Collections or the key type for Maps.
Constructor.
List.
ConversionService used by the converter.
EntityManager.
EntityInformation the repository factory is using.
EntityInformation for the given domain class.
MappingContext?
TypeInformation in case none could be extracted from the given source.
GlobalRepositoryConfigInformation implementation for the given element.
PersistentEntity.
Parameters.
PersistentPropertyPath.
PersistentPropertyPath.
MappingContext used by the converter.
Map.
Map.
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 wrapper to gain additional information about Method parameters.
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.
PersistentEntitys held in the context.
PersistentEntity for the given Class.
PersistentEntity for the given TypeInformation.
TypeInformation if the property references a PersistentEntity.
PersistentPropertys for the given path expression based on the given PropertyPath.
PreferredConstructor to be used to instantiate objects of this PersistentEntity.
PersistentProperty of the underlying bean instance.
PersistentProperty potentially converted to the given type.
PropertyDescriptor backing the PersistentProperty.
QueryLookupStrategy for the given QueryLookupStrategy.Key.
Repository the factory will create.
Method.
TypeInformation for the return type of the given Method.
PropertyPath.
SingleRepositoryConfigInformation instances used for manual configuration.
Sort specification parsed from the source or null.
Sort Method parameter if available.
Value annotation at the property and returns the String value of
it.
PlatformTransactionManager to be used.
TypeInformation of the parameter.
Iterable or the value type of a Map if the property is one.
Parameter.
TypeInformation backing this PersistentEntity.
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).
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.
PersistenceConstructor).
Repository interface.
Id annotation found on it.
PersistentEntity.
Map.
Map.
Param.
Persistable is new or was persisted already.
Page of results.
Transient, Value or Autowired as
transien.
PersistentEntitys.NamedQueries that can be looked up by their names.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 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.Pageable instances into controller
methods.Pageable into a controller method.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.SingleRepositoryConfigInformation implementations.ParentDelegatingRepositoryConfigInformation with the given
CommonRepositoryConfigInformation as parent.
TypeInformation implementations that need parent type awareness.ParentTypeAwareTypeInformation.
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.
PersistentPropertys.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.
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.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.
AbstractBeanDefinition and registers it inside the given
BeanDefinitionRegistry.
repositories element in
XML namespcae configuration.RepositoryConfig.
FactoryBean interface to allow easy setup of repository factories via Spring
configuration.EntityInformation this interfaceMethodInterceptor intercepts calls to methods of the custom implementation and delegates the to it if
configured.RepositoryFactorySupport.QueryExecutorMethodInterceptor.
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.
Pageable that is being used to back missing parameters.
Set of types to populate the context initially.
NamedQueries instance.
NamedQueries instance to be handed to the QueryLookupStrategy for query creation.
PersistentProperty to the given value.
PersistentProperty to the given value.
QueryLookupStrategy.Key to be used.
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.
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.
Sort instance.
Sort instance.
Sort instance.
Order and a property.Sort.Order instance. if order is null then order defaults to
Sort.Order instance.
ParameterValueProvider implementation that evaluates the PreferredConstructor.Parameters key against
SpelExpressionParser and EvaluationContext.SpELAwareParameterValueProvider from the given SpelExpressionParser and
EvaluationContext.
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.UserCredentials instance from the given username and password.
PersistentEntity.
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.
|
Spring Data Commons | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||