|
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 | |||||||||