| 
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.
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.
PersistentProperty that takes annotations at a property into account.AnnotationBasedPersistentProperty.
RepositoryMetadata implementation inspecting the given repository interface for 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.
Class.ClassTypeInformation for the given type.
Sort definition.
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.
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.
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.
Property chain from the given source String
 and type.
ClassTypeInformation.
Part.Type of the Part for the given raw
 property and the given Class.
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.
Parameters instance with effectively all special
 parameters removed.
Collection.
Collections or the key type for Maps.
Constructor.
List.
EntityInformation the repository factory is using.
EntityInformation for the given domain class.
MappingContext?
GlobalRepositoryConfigInformation implementation for
 the given element.
PersistentEntity.
Parameters.
Map.
Map.
Param annotation) or
 null if none can be found.
Property.
Parameter from the surrounding
 Parameters.
Methods parameters.
Property.
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.
Iterable of all parts contained in the
 PartTree.
PersistentEntitys held in the context.
PersistentEntity for the given Class.
PersistentEntity for the given TypeInformation.
PersistentPropertys for the given path expression based on the given root Class.
PreferredConstructor to be used to instantiate objects of this PersistentEntity.
PersistentProperty of the underlying bean instance.
PersistentProperty potentially converted to the given type.
QueryLookupStrategy for the given QueryLookupStrategy.Key.
Repository the factory will create.
Method.
SingleRepositoryConfigInformation instances used for
 manual configuration.
Sort specification parsed from the source.
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.
Parameter.
Iterable or the
 value type of a Map if the property is one.
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.
Property.
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.
Parameter is to be bound to a query.
Property is actually a collection.
Collection and Array or anything implementing Iterable.
PersistentEntity.
PersistenceConstructor).
Repository interface.
Id annotation found on it.
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.
Property.
RepositoryQuery was created.
Sort instance from a method name end.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 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.
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.
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.
NamedQueries implementation backed by a Properties instance.PropertiesBasedNamedQueries for the given Properties instance.
Property of a domain class.PersistentProperty
 instances except associations and transient properties.QueryMethod.RepositoryQuery creation.Predicate instances.RepositoryQuerys.QueryMethod from the given parameters.
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.
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.
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.
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.
Property path in dot notation.
RepositoryFactoryBeanSupport to add transactional
 capabilities to the repository proxy.PersistentEntity.
Sort.Order with the given Sort.Order.
Sort instance for the given properties.
  | 
Spring Data Commons | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||