Package | Description |
---|---|
org.springframework.beans.factory |
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
|
org.springframework.beans.factory.config |
SPI interfaces and configuration-related convenience classes for bean factories.
|
org.springframework.beans.factory.support |
Classes supporting the
org.springframework.beans.factory package. |
org.springframework.context.annotation |
Annotation support for the Application Context, including JSR-250 "common"
annotations, component-scanning, and Java-based metadata for creating
Spring-managed objects.
|
org.springframework.context.support |
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
|
org.springframework.jndi.support |
Support classes for JNDI usage,
including a JNDI-based BeanFactory implementation.
|
org.springframework.orm.jpa |
Package providing integration of JPA (Java Persistence API) with Spring concepts.
|
org.springframework.orm.jpa.support |
Classes supporting the
org.springframework.orm.jpa package. |
Modifier and Type | Class and Description |
---|---|
class |
NoUniqueBeanDefinitionException
Exception thrown when a
BeanFactory is asked for a bean instance for which
multiple matching candidates have been found when only one matching bean was expected. |
Modifier and Type | Method and Description |
---|---|
<A extends Annotation> |
ListableBeanFactory.findAnnotationOnBean(String beanName,
Class<A> annotationType)
Find an
Annotation of annotationType on the specified bean,
traversing its interfaces and super classes if no annotation can be found on
the given class itself. |
Class<?> |
BeanFactory.getType(String name)
Determine the type of the bean with the given name.
|
boolean |
BeanFactory.isPrototype(String name)
Is this bean a prototype? That is, will
BeanFactory.getBean(java.lang.String) always return
independent instances? |
boolean |
BeanFactory.isSingleton(String name)
Is this bean a shared singleton? That is, will
BeanFactory.getBean(java.lang.String) always
return the same instance? |
boolean |
BeanFactory.isTypeMatch(String name,
Class<?> typeToMatch)
Check whether the bean with the given name matches the specified type.
|
boolean |
BeanFactory.isTypeMatch(String name,
ResolvableType typeToMatch)
Check whether the bean with the given name matches the specified type.
|
Modifier and Type | Method and Description |
---|---|
BeanDefinition |
ConfigurableListableBeanFactory.getBeanDefinition(String beanName)
Return the registered BeanDefinition for the specified bean, allowing access
to its property values and constructor argument value (which can be
modified during bean factory post-processing).
|
BeanDefinition |
ConfigurableBeanFactory.getMergedBeanDefinition(String beanName)
Return a merged BeanDefinition for the given bean name,
merging a child bean definition with its parent if necessary.
|
boolean |
ConfigurableListableBeanFactory.isAutowireCandidate(String beanName,
DependencyDescriptor descriptor)
Determine whether the specified bean qualifies as an autowire candidate,
to be injected into other beans which declare a dependency of matching type.
|
boolean |
ConfigurableBeanFactory.isFactoryBean(String name)
Determine whether the bean with the given name is a FactoryBean.
|
Modifier and Type | Method and Description |
---|---|
<A extends Annotation> |
DefaultListableBeanFactory.findAnnotationOnBean(String beanName,
Class<A> annotationType) |
<A extends Annotation> |
StaticListableBeanFactory.findAnnotationOnBean(String beanName,
Class<A> annotationType) |
BeanDefinition |
SimpleBeanDefinitionRegistry.getBeanDefinition(String beanName) |
BeanDefinition |
BeanDefinitionRegistry.getBeanDefinition(String beanName)
Return the BeanDefinition for the given bean name.
|
BeanDefinition |
DefaultListableBeanFactory.getBeanDefinition(String beanName) |
Class<?> |
AbstractBeanFactory.getType(String name) |
Class<?> |
StaticListableBeanFactory.getType(String name) |
boolean |
DefaultListableBeanFactory.isAutowireCandidate(String beanName,
DependencyDescriptor descriptor) |
protected boolean |
DefaultListableBeanFactory.isAutowireCandidate(String beanName,
DependencyDescriptor descriptor,
AutowireCandidateResolver resolver)
Determine whether the specified bean definition qualifies as an autowire candidate,
to be injected into other beans which declare a dependency of matching type.
|
boolean |
AbstractBeanFactory.isFactoryBean(String name) |
boolean |
AbstractBeanFactory.isPrototype(String name) |
boolean |
StaticListableBeanFactory.isPrototype(String name) |
boolean |
AbstractBeanFactory.isSingleton(String name) |
boolean |
StaticListableBeanFactory.isSingleton(String name) |
boolean |
AbstractBeanFactory.isTypeMatch(String name,
Class<?> typeToMatch) |
boolean |
StaticListableBeanFactory.isTypeMatch(String name,
Class<?> typeToMatch) |
boolean |
AbstractBeanFactory.isTypeMatch(String name,
ResolvableType typeToMatch) |
boolean |
StaticListableBeanFactory.isTypeMatch(String name,
ResolvableType typeToMatch) |
void |
SimpleBeanDefinitionRegistry.removeBeanDefinition(String beanName) |
void |
BeanDefinitionRegistry.removeBeanDefinition(String beanName)
Remove the BeanDefinition for the given name.
|
void |
DefaultListableBeanFactory.removeBeanDefinition(String beanName) |
Modifier and Type | Method and Description |
---|---|
protected Object |
CommonAnnotationBeanPostProcessor.autowireResource(BeanFactory factory,
CommonAnnotationBeanPostProcessor.LookupElement element,
String requestingBeanName)
Obtain a resource object for the given name and type through autowiring
based on the given factory.
|
protected Object |
CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.LookupElement element,
String requestingBeanName)
Obtain the resource object for the given name and type.
|
Modifier and Type | Method and Description |
---|---|
<A extends Annotation> |
AbstractApplicationContext.findAnnotationOnBean(String beanName,
Class<A> annotationType) |
BeanDefinition |
GenericApplicationContext.getBeanDefinition(String beanName) |
Class<?> |
AbstractApplicationContext.getType(String name) |
boolean |
AbstractApplicationContext.isPrototype(String name) |
boolean |
AbstractApplicationContext.isSingleton(String name) |
boolean |
AbstractApplicationContext.isTypeMatch(String name,
Class<?> typeToMatch) |
boolean |
AbstractApplicationContext.isTypeMatch(String name,
ResolvableType typeToMatch) |
void |
GenericApplicationContext.removeBeanDefinition(String beanName) |
Modifier and Type | Method and Description |
---|---|
Class<?> |
SimpleJndiBeanFactory.getType(String name) |
boolean |
SimpleJndiBeanFactory.isPrototype(String name) |
boolean |
SimpleJndiBeanFactory.isSingleton(String name) |
boolean |
SimpleJndiBeanFactory.isTypeMatch(String name,
Class<?> typeToMatch) |
boolean |
SimpleJndiBeanFactory.isTypeMatch(String name,
ResolvableType typeToMatch) |
Modifier and Type | Method and Description |
---|---|
static EntityManagerFactory |
EntityManagerFactoryUtils.findEntityManagerFactory(ListableBeanFactory beanFactory,
String unitName)
Find an EntityManagerFactory with the given name in the given
Spring application context (represented as ListableBeanFactory).
|
Modifier and Type | Method and Description |
---|---|
protected EntityManagerFactory |
PersistenceAnnotationBeanPostProcessor.findDefaultEntityManagerFactory(String requestingBeanName)
Find a single default EntityManagerFactory in the Spring application context.
|
protected EntityManagerFactory |
PersistenceAnnotationBeanPostProcessor.findEntityManagerFactory(String unitName,
String requestingBeanName)
Find an EntityManagerFactory with the given name in the current Spring
application context, falling back to a single default EntityManagerFactory
(if any) in case of no unit name specified.
|
protected EntityManagerFactory |
PersistenceAnnotationBeanPostProcessor.findNamedEntityManagerFactory(String unitName,
String requestingBeanName)
Find an EntityManagerFactory with the given name in the current
Spring application context.
|