Also: SpringBeans

public class

DefaultListableBeanFactory

extends AbstractAutowireCapableBeanFactory
implements Serializable ConfigurableListableBeanFactory BeanDefinitionRegistry

java.lang.Object
↳	org.springframework.core.SimpleAliasRegistry
	↳	org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
		↳	org.springframework.beans.factory.support.FactoryBeanRegistrySupport
			↳	org.springframework.beans.factory.support.AbstractBeanFactory
				↳	org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
					↳	org.springframework.beans.factory.support.DefaultListableBeanFactory

Known Direct Subclasses

XmlBeanFactory

Class Overview

Default implementation of the ListableBeanFactory and BeanDefinitionRegistry interfaces: a full-fledged bean factory based on bean definition objects.

Typical usage is registering all bean definitions first (possibly read from a bean definition file), before accessing beans. Bean definition lookup is therefore an inexpensive operation in a local bean definition table, operating on pre-built bean definition metadata objects.

Can be used as a standalone bean factory, or as a superclass for custom bean factories. Note that readers for specific bean definition formats are typically implemented separately rather than as bean factory subclasses: see for example PropertiesBeanDefinitionReader and XmlBeanDefinitionReader.

For an alternative implementation of the ListableBeanFactory interface, have a look at StaticListableBeanFactory, which manages existing bean instances rather than creating new ones based on bean definitions.

Summary

[Expand]

Inherited Constants

From interface org.springframework.beans.factory.BeanFactory

From interface org.springframework.beans.factory.config.AutowireCapableBeanFactory

From interface org.springframework.beans.factory.config.ConfigurableBeanFactory

[Expand]

Inherited Fields

From class org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

Public Constructors
	DefaultListableBeanFactory() Create a new DefaultListableBeanFactory.
	DefaultListableBeanFactory(BeanFactory parentBeanFactory) Create a new DefaultListableBeanFactory with the given parent.

Public Methods
boolean	containsBeanDefinition(String beanName) Check if this bean factory contains a bean definition with the given name.
void	copyConfigurationFrom(ConfigurableBeanFactory otherFactory) Copy all relevant configuration from the given other factory.
<A extends Annotation> A	findAnnotationOnBean(String beanName, Class<A> annotationType) Find a `Annotation` of `annotationType` on the specified bean, traversing its interfaces and super classes if no annotation can be found on the given class itself, as well as checking its raw bean class if not found on the exposed bean reference (e.g.
void	freezeConfiguration() Freeze all bean definitions, signalling that the registered bean definitions will not be modified or post-processed any further.
AutowireCandidateResolver	getAutowireCandidateResolver() Return the autowire candidate resolver for this BeanFactory (never `null`).
<T> T	getBean(Class<T> requiredType) Return the bean instance that uniquely matches the given object type, if any.
BeanDefinition	getBeanDefinition(String beanName) Return the bean definition for the given bean name.
int	getBeanDefinitionCount() Return the number of beans defined in the factory.
String[]	getBeanDefinitionNames() Return the names of all beans defined in this factory.
String[]	getBeanNamesForType(Class type, boolean includeNonSingletons, boolean allowEagerInit)
String[]	getBeanNamesForType(Class type)
<T> Map<String, T>	getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) Return the bean instances that match the given object type (including subclasses), judging from either bean definitions or the value of `getObjectType` in the case of FactoryBeans.
<T> Map<String, T>	getBeansOfType(Class<T> type) Return the bean instances that match the given object type (including subclasses), judging from either bean definitions or the value of `getObjectType` in the case of FactoryBeans.
Map<String, Object>	getBeansWithAnnotation(Class<? extends Annotation> annotationType) Find all beans whose `Class` has the supplied `Annotation` type.
boolean	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	isConfigurationFrozen() Return whether this factory's bean definitions are frozen, i.e.
void	preInstantiateSingletons() Ensure that all non-lazy-init singletons are instantiated, also considering `FactoryBeans`.
void	registerBeanDefinition(String beanName, BeanDefinition beanDefinition) Register a new bean definition with this registry.
void	registerResolvableDependency(Class<?> dependencyType, Object autowiredValue) Register a special dependency type with corresponding autowired value.
void	removeBeanDefinition(String beanName) Remove the BeanDefinition for the given name.
Object	resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) Resolve the specified dependency against the beans defined in this factory.
void	setAllowBeanDefinitionOverriding(boolean allowBeanDefinitionOverriding) Set whether it should be allowed to override bean definitions by registering a different definition with the same name, automatically replacing the former.
void	setAllowEagerClassLoading(boolean allowEagerClassLoading) Set whether the factory is allowed to eagerly load bean classes even for bean definitions that are marked as "lazy-init".
void	setAutowireCandidateResolver(AutowireCandidateResolver autowireCandidateResolver) Set a custom autowire candidate resolver for this BeanFactory to use when deciding whether a bean definition should be considered as a candidate for autowiring.
void	setSerializationId(String serializationId) Specify an id for serialization purposes, allowing this BeanFactory to be deserialized from this id back into the BeanFactory object, if needed.
String	toString()

Protected Methods
boolean	allowAliasOverriding() Only allows alias overriding if bean definition overriding is allowed.
String	determinePrimaryCandidate(Map<String, Object> candidateBeans, DependencyDescriptor descriptor) Determine the primary autowire candidate in the given set of beans.
Object	doResolveDependency(DependencyDescriptor descriptor, Class<?> type, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)
Map<String, Object>	findAutowireCandidates(String beanName, Class requiredType, DependencyDescriptor descriptor) Find bean instances that match the required type.
boolean	isAutowireCandidate(String beanName, RootBeanDefinition mbd, DependencyDescriptor descriptor) 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	isBeanEligibleForMetadataCaching(String beanName) Considers all beans as eligible for metdata caching if the factory's configuration has been marked as frozen.
boolean	isPrimary(String beanName, Object beanInstance) Return whether the bean definition for the given bean name has been marked as a primary bean.
boolean	matchesBeanName(String beanName, String candidateName) Determine whether the given candidate name matches the bean name or the aliases stored in this bean definition.
void	resetBeanDefinition(String beanName) Reset all bean definition caches for the given bean, including the caches of beans that are derived from it.
Object	writeReplace()

[Expand]

Inherited Methods

From class org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

From class org.springframework.beans.factory.support.AbstractBeanFactory

From class org.springframework.beans.factory.support.FactoryBeanRegistrySupport

From class org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

void	addSingleton(String beanName, Object singletonObject) Add the given singleton object to the singleton cache of this factory.
void	addSingletonFactory(String beanName, ObjectFactory singletonFactory) Add the given singleton factory for building the specified singleton if necessary.
void	afterSingletonCreation(String beanName) Callback after singleton creation.
void	beforeSingletonCreation(String beanName) Callback before singleton creation.
boolean	containsSingleton(String beanName) Check if this registry contains a singleton instance with the given name.
void	destroyBean(String beanName, DisposableBean bean) Destroy the given bean.
void	destroySingleton(String beanName) Destroy the given bean.
void	destroySingletons()
String[]	getDependenciesForBean(String beanName) Return the names of all beans that the specified bean depends on, if any.
String[]	getDependentBeans(String beanName) Return the names of all beans which depend on the specified bean, if any.
Object	getSingleton(String beanName, ObjectFactory singletonFactory) Return the (raw) singleton object registered under the given name, creating and registering a new one if none registered yet.
Object	getSingleton(String beanName, boolean allowEarlyReference) Return the (raw) singleton object registered under the given name.
Object	getSingleton(String beanName) Return the (raw) singleton object registered under the given name.
int	getSingletonCount() Return the number of singleton beans registered in this registry.
final Object	getSingletonMutex() Expose the singleton mutex to subclasses.
String[]	getSingletonNames() Return the names of singleton beans registered in this registry.
boolean	hasDependentBean(String beanName) Determine whether a dependent bean has been registered for the given name.
final boolean	isSingletonCurrentlyInCreation(String beanName) Return whether the specified singleton bean is currently in creation (within the entire factory).
void	onSuppressedException(Exception ex) Register an Exception that happened to get suppressed during the creation of a singleton bean instance, e.g.
void	registerContainedBean(String containedBeanName, String containingBeanName) Register a containment relationship between two beans, e.g.
void	registerDependentBean(String beanName, String dependentBeanName) Register a dependent bean for the given bean, to be destroyed before the given bean is destroyed.
void	registerDisposableBean(String beanName, DisposableBean bean) Add the given bean to the list of disposable beans in this registry.
void	registerSingleton(String beanName, Object singletonObject) Register the given existing object as singleton in the bean registry, under the given bean name.
void	removeSingleton(String beanName) Remove the bean with the given name from the singleton cache of this factory, to be able to clean up eager registration of a singleton if creation failed.

From class org.springframework.core.SimpleAliasRegistry

boolean	allowAliasOverriding() Return whether alias overriding is allowed.
String	canonicalName(String name) Determine the raw name, resolving aliases to canonical names.
void	checkForAliasCircle(String name, String alias) Check whether the given name points back to given alias as an alias in the other direction, catching a circular reference upfront and throwing a corresponding IllegalStateException.
String[]	getAliases(String name) Return the aliases for the given name, if defined.
boolean	isAlias(String name) Determine whether this given name is defines as an alias (as opposed to the name of an actually registered component).
void	registerAlias(String name, String alias) Given a name, register an alias for it.
void	removeAlias(String alias) Remove the specified alias from this registry.
void	resolveAliases(StringValueResolver valueResolver) Resolve all alias target names and aliases registered in this factory, applying the given StringValueResolver to them.

From class java.lang.Object

From interface org.springframework.beans.factory.BeanFactory

abstract boolean	containsBean(String name) Does this bean factory contain a bean with the given name? More specifically, is `getBean(Class)` able to obtain a bean instance for the given name? Translates aliases back to the corresponding canonical bean name.
abstract String[]	getAliases(String name) Return the aliases for the given bean name, if any.
abstract Object	getBean(String name) Return an instance, which may be shared or independent, of the specified bean.
abstract Object	getBean(String name, Object... args) Return an instance, which may be shared or independent, of the specified bean.
abstract <T> T	getBean(Class<T> requiredType) Return the bean instance that uniquely matches the given object type, if any.
abstract <T> T	getBean(String name, Class<T> requiredType) Return an instance, which may be shared or independent, of the specified bean.
abstract Class<?>	getType(String name) Determine the type of the bean with the given name.
abstract boolean	isPrototype(String name) Is this bean a prototype? That is, will `getBean(Class)` always return independent instances? Note: This method returning `false` does not clearly indicate a singleton object.
abstract boolean	isSingleton(String name) Is this bean a shared singleton? That is, will `getBean(Class)` always return the same instance? Note: This method returning `false` does not clearly indicate independent instances.
abstract boolean	isTypeMatch(String name, Class<?> targetType) Check whether the bean with the given name matches the specified type.

From interface org.springframework.beans.factory.HierarchicalBeanFactory

From interface org.springframework.beans.factory.ListableBeanFactory

abstract boolean	containsBeanDefinition(String beanName) Check if this bean factory contains a bean definition with the given name.
abstract <A extends Annotation> A	findAnnotationOnBean(String beanName, Class<A> annotationType) Find a `Annotation` of `annotationType` on the specified bean, traversing its interfaces and super classes if no annotation can be found on the given class itself.
abstract int	getBeanDefinitionCount() Return the number of beans defined in the factory.
abstract String[]	getBeanDefinitionNames() Return the names of all beans defined in this factory.
abstract String[]	getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) Return the names of beans matching the given type (including subclasses), judging from either bean definitions or the value of `getObjectType` in the case of FactoryBeans.
abstract String[]	getBeanNamesForType(Class<?> type) Return the names of beans matching the given type (including subclasses), judging from either bean definitions or the value of `getObjectType` in the case of FactoryBeans.
abstract <T> Map<String, T>	getBeansOfType(Class<T> type) Return the bean instances that match the given object type (including subclasses), judging from either bean definitions or the value of `getObjectType` in the case of FactoryBeans.
abstract <T> Map<String, T>	getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) Return the bean instances that match the given object type (including subclasses), judging from either bean definitions or the value of `getObjectType` in the case of FactoryBeans.
abstract Map<String, Object>	getBeansWithAnnotation(Class<? extends Annotation> annotationType) Find all beans whose `Class` has the supplied `Annotation` type.

From interface org.springframework.beans.factory.config.AutowireCapableBeanFactory

abstract Object	applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessAfterInitialization` methods.
abstract Object	applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessBeforeInitialization` methods.
abstract void	applyBeanPropertyValues(Object existingBean, String beanName) Apply the property values of the bean definition with the given name to the given bean instance.
abstract Object	autowire(Class beanClass, int autowireMode, boolean dependencyCheck) Instantiate a new bean instance of the given class with the specified autowire strategy.
abstract void	autowireBean(Object existingBean) Populate the given bean instance through applying after-instantiation callbacks and bean property post-processing (e.g.
abstract void	autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck) Autowire the bean properties of the given bean instance by name or type.
abstract Object	configureBean(Object existingBean, String beanName) Configure the given raw bean: autowiring bean properties, applying bean property values, applying factory callbacks such as `setBeanName` and `setBeanFactory`, and also applying all bean post processors (including ones which might wrap the given raw bean).
abstract Object	createBean(Class beanClass, int autowireMode, boolean dependencyCheck) Fully create a new bean instance of the given class with the specified autowire strategy.
abstract <T> T	createBean(Class<T> beanClass) Fully create a new bean instance of the given class.
abstract Object	initializeBean(Object existingBean, String beanName) Initialize the given raw bean, applying factory callbacks such as `setBeanName` and `setBeanFactory`, also applying all bean post processors (including ones which might wrap the given raw bean).
abstract Object	resolveDependency(DependencyDescriptor descriptor, String beanName) Resolve the specified dependency against the beans defined in this factory.
abstract Object	resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) Resolve the specified dependency against the beans defined in this factory.

From interface org.springframework.beans.factory.config.ConfigurableBeanFactory

abstract void	addBeanPostProcessor(BeanPostProcessor beanPostProcessor) Add a new BeanPostProcessor that will get applied to beans created by this factory.
abstract void	addEmbeddedValueResolver(StringValueResolver valueResolver) Add a String resolver for embedded values such as annotation attributes.
abstract void	addPropertyEditorRegistrar(PropertyEditorRegistrar registrar) Add a PropertyEditorRegistrar to be applied to all bean creation processes.
abstract void	copyConfigurationFrom(ConfigurableBeanFactory otherFactory) Copy all relevant configuration from the given other factory.
abstract void	copyRegisteredEditorsTo(PropertyEditorRegistry registry) Initialize the given PropertyEditorRegistry with the custom editors that have been registered with this BeanFactory.
abstract void	destroyBean(String beanName, Object beanInstance) Destroy the given bean instance (usually a prototype instance obtained from this factory) according to its bean definition.
abstract void	destroyScopedBean(String beanName) Destroy the specified scoped bean in the current target scope, if any.
abstract void	destroySingletons() Destroy all singleton beans in this factory, including inner beans that have been registered as disposable.
abstract AccessControlContext	getAccessControlContext() Provides a security access control context relevant to this factory.
abstract ClassLoader	getBeanClassLoader() Return this factory's class loader for loading bean classes.
abstract BeanExpressionResolver	getBeanExpressionResolver() Return the resolution strategy for expressions in bean definition values.
abstract int	getBeanPostProcessorCount() Return the current number of registered BeanPostProcessors, if any.
abstract ConversionService	getConversionService() Return the associated ConversionService, if any.
abstract String[]	getDependenciesForBean(String beanName) Return the names of all beans that the specified bean depends on, if any.
abstract String[]	getDependentBeans(String beanName) Return the names of all beans which depend on the specified bean, if any.
abstract BeanDefinition	getMergedBeanDefinition(String beanName) Return a merged BeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.
abstract Scope	getRegisteredScope(String scopeName) Return the Scope implementation for the given scope name, if any.
abstract String[]	getRegisteredScopeNames() Return the names of all currently registered scopes.
abstract ClassLoader	getTempClassLoader() Return the temporary ClassLoader to use for type matching purposes, if any.
abstract TypeConverter	getTypeConverter() Obtain a type converter as used by this BeanFactory.
abstract boolean	isCacheBeanMetadata() Return whether to cache bean metadata such as given bean definitions (in merged fashion) and resolved bean classes.
abstract boolean	isCurrentlyInCreation(String beanName) Determine whether the specified bean is currently in creation.
abstract boolean	isFactoryBean(String name) Determine whether the bean with the given name is a FactoryBean.
abstract void	registerAlias(String beanName, String alias) Given a bean name, create an alias.
abstract void	registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass) Register the given custom property editor for all properties of the given type.
abstract void	registerDependentBean(String beanName, String dependentBeanName) Register a dependent bean for the given bean, to be destroyed before the given bean is destroyed.
abstract void	registerScope(String scopeName, Scope scope) Register the given scope, backed by the given Scope implementation.
abstract void	resolveAliases(StringValueResolver valueResolver) Resolve all alias target names and aliases registered in this factory, applying the given StringValueResolver to them.
abstract String	resolveEmbeddedValue(String value) Resolve the given embedded value, e.g.
abstract void	setBeanClassLoader(ClassLoader beanClassLoader) Set the class loader to use for loading bean classes.
abstract void	setBeanExpressionResolver(BeanExpressionResolver resolver) Specify the resolution strategy for expressions in bean definition values.
abstract void	setCacheBeanMetadata(boolean cacheBeanMetadata) Set whether to cache bean metadata such as given bean definitions (in merged fashion) and resolved bean classes.
abstract void	setConversionService(ConversionService conversionService) Specify a Spring 3.0 ConversionService to use for converting property values, as an alternative to JavaBeans PropertyEditors.
abstract void	setParentBeanFactory(BeanFactory parentBeanFactory) Set the parent of this bean factory.
abstract void	setTempClassLoader(ClassLoader tempClassLoader) Specify a temporary ClassLoader to use for type matching purposes.
abstract void	setTypeConverter(TypeConverter typeConverter) Set a custom type converter that this BeanFactory should use for converting bean property values, constructor argument values, etc.

From interface org.springframework.beans.factory.config.ConfigurableListableBeanFactory

abstract void	freezeConfiguration() Freeze all bean definitions, signalling that the registered bean definitions will not be modified or post-processed any further.
abstract BeanDefinition	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).
abstract void	ignoreDependencyInterface(Class<?> ifc) Ignore the given dependency interface for autowiring.
abstract void	ignoreDependencyType(Class<?> type) Ignore the given dependency type for autowiring: for example, String.
abstract boolean	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.
abstract boolean	isConfigurationFrozen() Return whether this factory's bean definitions are frozen, i.e.
abstract void	preInstantiateSingletons() Ensure that all non-lazy-init singletons are instantiated, also considering `FactoryBeans`.
abstract void	registerResolvableDependency(Class<?> dependencyType, Object autowiredValue) Register a special dependency type with corresponding autowired value.

From interface org.springframework.beans.factory.config.SingletonBeanRegistry

From interface org.springframework.beans.factory.support.BeanDefinitionRegistry

From interface org.springframework.core.AliasRegistry

Public Constructors

public DefaultListableBeanFactory ()

Also: SpringBeans

Create a new DefaultListableBeanFactory.

public DefaultListableBeanFactory (BeanFactory parentBeanFactory)

Also: SpringBeans

Create a new DefaultListableBeanFactory with the given parent.

Parameters

parentBeanFactory	the parent BeanFactory

Public Methods

public boolean containsBeanDefinition (String beanName)

Also: SpringBeans

Check if this bean factory contains a bean definition with the given name. Does not consider any hierarchy this factory may participate in. Invoked by containsBean when no cached singleton instance is found.

Depending on the nature of the concrete bean factory implementation, this operation might be expensive (for example, because of directory lookups in external registries). However, for listable bean factories, this usually just amounts to a local hash lookup: The operation is therefore part of the public interface there. The same implementation can serve for both this template method and the public interface method in that case.

Parameters

beanName	the name of the bean to look for

Returns

if this bean factory contains a bean definition with the given name

public void copyConfigurationFrom (ConfigurableBeanFactory otherFactory)

Also: SpringBeans

Copy all relevant configuration from the given other factory.

Should include all standard configuration settings as well as BeanPostProcessors, Scopes, and factory-specific internal settings. Should not include any metadata of actual bean definitions, such as BeanDefinition objects and bean name aliases.

Parameters

otherFactory	the other BeanFactory to copy from

public A findAnnotationOnBean (String beanName, Class<A> annotationType)

Also: SpringBeans

Find a Annotation of annotationType on the specified bean, traversing its interfaces and super classes if no annotation can be found on the given class itself, as well as checking its raw bean class if not found on the exposed bean reference (e.g. in case of a proxy).

Parameters

beanName	the name of the bean to look for annotations on
annotationType	the annotation class to look for

Returns

the annotation of the given type found, or null

public void freezeConfiguration ()

Also: SpringBeans

Freeze all bean definitions, signalling that the registered bean definitions will not be modified or post-processed any further.

This allows the factory to aggressively cache bean definition metadata.

public AutowireCandidateResolver getAutowireCandidateResolver ()

Also: SpringBeans

Return the autowire candidate resolver for this BeanFactory (never null).

public T getBean (Class<T> requiredType)

Also: SpringBeans

Return the bean instance that uniquely matches the given object type, if any.

Parameters

requiredType	type the bean must match; can be an interface or superclass. `null` is disallowed. This method goes into ListableBeanFactory by-type lookup territory but may also be translated into a conventional by-name lookup based on the name of the given type. For more extensive retrieval operations across sets of beans, use ListableBeanFactory and/or `BeanFactoryUtils`.

Returns

an instance of the single bean matching the required type

Throws

BeansException

public BeanDefinition getBeanDefinition (String beanName)

Also: SpringBeans

Return the bean definition for the given bean name. Subclasses should normally implement caching, as this method is invoked by this class every time bean definition metadata is needed.

Depending on the nature of the concrete bean factory implementation, this operation might be expensive (for example, because of directory lookups in external registries). However, for listable bean factories, this usually just amounts to a local hash lookup: The operation is therefore part of the public interface there. The same implementation can serve for both this template method and the public interface method in that case.

Parameters

beanName	the name of the bean to find a definition for

Returns

the BeanDefinition for this prototype name (never null)

Throws

NoSuchBeanDefinitionException

public int getBeanDefinitionCount ()

Also: SpringBeans

Return the number of beans defined in the factory.

Does not consider any hierarchy this factory may participate in, and ignores any singleton beans that have been registered by other means than bean definitions.

Returns

the number of beans defined in the factory

public String[] getBeanDefinitionNames ()

Also: SpringBeans

Return the names of all beans defined in this factory.

Does not consider any hierarchy this factory may participate in, and ignores any singleton beans that have been registered by other means than bean definitions.

Returns

the names of all beans defined in this factory, or an empty array if none defined

public String[] getBeanNamesForType (Class type, boolean includeNonSingletons, boolean allowEagerInit)

Also: SpringBeans

public String[] getBeanNamesForType (Class type)

Also: SpringBeans

public Map<String, T> getBeansOfType (Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)

Also: SpringBeans

Return the bean instances that match the given object type (including subclasses), judging from either bean definitions or the value of getObjectType in the case of FactoryBeans.

NOTE: This method introspects top-level beans only. It does not check nested beans which might match the specified type as well.

Does consider objects created by FactoryBeans if the "allowEagerInit" flag is set, which means that FactoryBeans will get initialized. If the object created by the FactoryBean doesn't match, the raw FactoryBean itself will be matched against the type. If "allowEagerInit" is not set, only raw FactoryBeans will be checked (which doesn't require initialization of each FactoryBean).

Does not consider any hierarchy this factory may participate in. Use BeanFactoryUtils' beansOfTypeIncludingAncestors to include beans in ancestor factories too.

Note: Does not ignore singleton beans that have been registered by other means than bean definitions.

The Map returned by this method should always return bean names and corresponding bean instances in the order of definition in the backend configuration, as far as possible.

Parameters

type	the class or interface to match, or `null` for all concrete beans
includeNonSingletons	whether to include prototype or scoped beans too or just singletons (also applies to FactoryBeans)
allowEagerInit	whether to initialize lazy-init singletons and objects created by FactoryBeans (or by factory methods with a "factory-bean" reference) for the type check. Note that FactoryBeans need to be eagerly initialized to determine their type: So be aware that passing in "true" for this flag will initialize FactoryBeans and "factory-bean" references.

Returns

a Map with the matching beans, containing the bean names as keys and the corresponding bean instances as values

Throws

BeansException

public Map<String, T> getBeansOfType (Class<T> type)

Also: SpringBeans

Return the bean instances that match the given object type (including subclasses), judging from either bean definitions or the value of getObjectType in the case of FactoryBeans.

NOTE: This method introspects top-level beans only. It does not check nested beans which might match the specified type as well.

Does consider objects created by FactoryBeans, which means that FactoryBeans will get initialized. If the object created by the FactoryBean doesn't match, the raw FactoryBean itself will be matched against the type.

Does not consider any hierarchy this factory may participate in. Use BeanFactoryUtils' beansOfTypeIncludingAncestors to include beans in ancestor factories too.

Note: Does not ignore singleton beans that have been registered by other means than bean definitions.

This version of getBeansOfType matches all kinds of beans, be it singletons, prototypes, or FactoryBeans. In most implementations, the result will be the same as for getBeansOfType(type, true, true).

The Map returned by this method should always return bean names and corresponding bean instances in the order of definition in the backend configuration, as far as possible.

Parameters

type	the class or interface to match, or `null` for all concrete beans

Returns

a Map with the matching beans, containing the bean names as keys and the corresponding bean instances as values

Throws

BeansException

public Map<String, Object> getBeansWithAnnotation (Class<? extends Annotation> annotationType)

Also: SpringBeans

Find all beans whose Class has the supplied Annotation type.

Parameters

annotationType	the type of annotation to look for

Returns

a Map with the matching beans, containing the bean names as keys and the corresponding bean instances as values

public boolean isAutowireCandidate (String beanName, DependencyDescriptor descriptor)

Also: SpringBeans

Determine whether the specified bean qualifies as an autowire candidate, to be injected into other beans which declare a dependency of matching type.

This method checks ancestor factories as well.

Parameters

beanName	the name of the bean to check
descriptor	the descriptor of the dependency to resolve

Returns

whether the bean should be considered as autowire candidate

Throws

NoSuchBeanDefinitionException

public boolean isConfigurationFrozen ()

Also: SpringBeans

Return whether this factory's bean definitions are frozen, i.e. are not supposed to be modified or post-processed any further.

Returns

true if the factory's configuration is considered frozen

public void preInstantiateSingletons ()

Also: SpringBeans

Ensure that all non-lazy-init singletons are instantiated, also considering FactoryBeans. Typically invoked at the end of factory setup, if desired.

Throws

BeansException

public void registerBeanDefinition (String beanName, BeanDefinition beanDefinition)

Also: SpringBeans

Register a new bean definition with this registry. Must support RootBeanDefinition and ChildBeanDefinition.

Parameters

beanName	the name of the bean instance to register
beanDefinition	definition of the bean instance to register

Throws

BeanDefinitionStoreException

public void registerResolvableDependency (Class<?> dependencyType, Object autowiredValue)

Also: SpringBeans

Register a special dependency type with corresponding autowired value.

This is intended for factory/context references that are supposed to be autowirable but are not defined as beans in the factory: e.g. a dependency of type ApplicationContext resolved to the ApplicationContext instance that the bean is living in.

Note: There are no such default types registered in a plain BeanFactory, not even for the BeanFactory interface itself.

Parameters

dependencyType	the dependency type to register. This will typically be a base interface such as BeanFactory, with extensions of it resolved as well if declared as an autowiring dependency (e.g. ListableBeanFactory), as long as the given value actually implements the extended interface.
autowiredValue	the corresponding autowired value. This may also be an implementation of the `ObjectFactory` interface, which allows for lazy resolution of the actual target value.

public void removeBeanDefinition (String beanName)

Also: SpringBeans

Remove the BeanDefinition for the given name.

Parameters

beanName	the name of the bean instance to register

Throws

NoSuchBeanDefinitionException

public Object resolveDependency (DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)

Also: SpringBeans

Resolve the specified dependency against the beans defined in this factory.

Parameters

descriptor	the descriptor for the dependency
beanName	the name of the bean which declares the present dependency
autowiredBeanNames	a Set that all names of autowired beans (used for resolving the present dependency) are supposed to be added to
typeConverter	the TypeConverter to use for populating arrays and collections

Returns

the resolved object, or null if none found

Throws

BeansException

public void setAllowBeanDefinitionOverriding (boolean allowBeanDefinitionOverriding)

Also: SpringBeans

Set whether it should be allowed to override bean definitions by registering a different definition with the same name, automatically replacing the former. If not, an exception will be thrown. This also applies to overriding aliases.

Default is "true".

public void setAllowEagerClassLoading (boolean allowEagerClassLoading)

Also: SpringBeans

Set whether the factory is allowed to eagerly load bean classes even for bean definitions that are marked as "lazy-init".

Default is "true". Turn this flag off to suppress class loading for lazy-init beans unless such a bean is explicitly requested. In particular, by-type lookups will then simply ignore bean definitions without resolved class name, instead of loading the bean classes on demand just to perform a type check.

public void setAutowireCandidateResolver (AutowireCandidateResolver autowireCandidateResolver)

Also: SpringBeans

Set a custom autowire candidate resolver for this BeanFactory to use when deciding whether a bean definition should be considered as a candidate for autowiring.

public void setSerializationId (String serializationId)

Also: SpringBeans

Specify an id for serialization purposes, allowing this BeanFactory to be deserialized from this id back into the BeanFactory object, if needed.

public String toString ()

Also: SpringBeans

Protected Methods

protected boolean allowAliasOverriding ()

Also: SpringBeans

Only allows alias overriding if bean definition overriding is allowed.

protected String determinePrimaryCandidate (Map<String, Object> candidateBeans, DependencyDescriptor descriptor)

Also: SpringBeans

Determine the primary autowire candidate in the given set of beans.

Parameters

candidateBeans	a Map of candidate names and candidate instances that match the required type, as returned by `findAutowireCandidates(String, Class, DependencyDescriptor)`
descriptor	the target dependency to match against

Returns

the name of the primary candidate, or null if none found

protected Object doResolveDependency (DependencyDescriptor descriptor, Class<?> type, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)

Also: SpringBeans

Throws

BeansException

protected Map<String, Object> findAutowireCandidates (String beanName, Class requiredType, DependencyDescriptor descriptor)

Also: SpringBeans

Find bean instances that match the required type. Called during autowiring for the specified bean.

Parameters

beanName	the name of the bean that is about to be wired
requiredType	the actual type of bean to look for (may be an array component type or collection element type)
descriptor	the descriptor of the dependency to resolve

Returns

a Map of candidate names and candidate instances that match the required type (never null)

Throws

BeansException	in case of errors

protected boolean isAutowireCandidate (String beanName, RootBeanDefinition mbd, DependencyDescriptor descriptor)

Also: SpringBeans

Determine whether the specified bean definition qualifies as an autowire candidate, to be injected into other beans which declare a dependency of matching type.

Parameters

beanName	the name of the bean definition to check
mbd	the merged bean definition to check
descriptor	the descriptor of the dependency to resolve

Returns

whether the bean should be considered as autowire candidate

protected boolean isBeanEligibleForMetadataCaching (String beanName)

Also: SpringBeans

Considers all beans as eligible for metdata caching if the factory's configuration has been marked as frozen.

Parameters

beanName	the name of the bean

Returns

true if the bean's metadata may be cached at this point already

protected boolean isPrimary (String beanName, Object beanInstance)

Also: SpringBeans

Return whether the bean definition for the given bean name has been marked as a primary bean.

Parameters

beanName	the name of the bean
beanInstance	the corresponding bean instance

Returns

whether the given bean qualifies as primary

protected boolean matchesBeanName (String beanName, String candidateName)

Also: SpringBeans

Determine whether the given candidate name matches the bean name or the aliases stored in this bean definition.

protected void resetBeanDefinition (String beanName)

Also: SpringBeans

Reset all bean definition caches for the given bean, including the caches of beans that are derived from it.

Parameters

beanName	the name of the bean to reset

protected Object writeReplace ()

Also: SpringBeans

Throws

ObjectStreamException

Interfaces

Classes

Exceptions

DefaultListableBeanFactory

Class Overview

See Also

Summary

Public Constructors

public DefaultListableBeanFactory ()

public DefaultListableBeanFactory (BeanFactory parentBeanFactory)

Parameters

Public Methods

public boolean containsBeanDefinition (String beanName)

Parameters

Returns

public void copyConfigurationFrom (ConfigurableBeanFactory otherFactory)

Parameters

public A findAnnotationOnBean (String beanName, Class<A> annotationType)

Parameters

Returns

public void freezeConfiguration ()

public AutowireCandidateResolver getAutowireCandidateResolver ()

public T getBean (Class<T> requiredType)

Parameters

Returns

Throws

public BeanDefinition getBeanDefinition (String beanName)

Parameters

Returns

Throws

public int getBeanDefinitionCount ()

Returns

public String[] getBeanDefinitionNames ()

Returns

public String[] getBeanNamesForType (Class type, boolean includeNonSingletons, boolean allowEagerInit)

public String[] getBeanNamesForType (Class type)

public Map<String, T> getBeansOfType (Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)

Parameters

Returns

Throws

public Map<String, T> getBeansOfType (Class<T> type)

Parameters

Returns

Throws

public Map<String, Object> getBeansWithAnnotation (Class<? extends Annotation> annotationType)

Parameters

Returns

public boolean isAutowireCandidate (String beanName, DependencyDescriptor descriptor)

Parameters

Returns

Throws

public boolean isConfigurationFrozen ()

Returns

public void preInstantiateSingletons ()

Throws

public void registerBeanDefinition (String beanName, BeanDefinition beanDefinition)

Parameters

Throws

public void registerResolvableDependency (Class<?> dependencyType, Object autowiredValue)

Parameters

public void removeBeanDefinition (String beanName)

Parameters

Throws

public Object resolveDependency (DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)

Parameters

Returns

Throws

public void setAllowBeanDefinitionOverriding (boolean allowBeanDefinitionOverriding)

See Also

public void setAllowEagerClassLoading (boolean allowEagerClassLoading)

See Also

public void setAutowireCandidateResolver (AutowireCandidateResolver autowireCandidateResolver)

public void setSerializationId (String serializationId)

public String toString ()

Protected Methods

protected boolean allowAliasOverriding ()

protected String determinePrimaryCandidate (Map<String, Object> candidateBeans, DependencyDescriptor descriptor)

Parameters

Returns

protected Object doResolveDependency (DependencyDescriptor descriptor, Class<?> type, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter)