AbstractBeanFactory (Spring Framework) - Spring Framework 1.2.9 API 文档英文版

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.springframework.beans.factory.support
Class AbstractBeanFactory

java.lang.Object
  org.springframework.beans.factory.support.AbstractBeanFactory

All Implemented Interfaces:: BeanFactory, ConfigurableBeanFactory, HierarchicalBeanFactory

Direct Known Subclasses:: AbstractAutowireCapableBeanFactory

public abstract class AbstractBeanFactory
extends Object
implements ConfigurableBeanFactory
extends Object
implements ConfigurableBeanFactory

Abstract base class for BeanFactory implementations, providing the full capabilities of the ConfigurableBeanFactory SPI. Does not assume a listable bean factory: can therefore also be used as base class for bean factory implementations which obtain bean definitions from some backend resource (where bean definition access is an expensive operation).

This class provides singleton/prototype determination, singleton cache, FactoryBean handling, aliases, bean definition merging for child bean definitions, and bean destruction (DisposableBean interface, custom destroy methods). Furthermore, it can manage a bean factory hierarchy (delegating to the parent in case of an unknown bean), through implementing the HierarchicalBeanFactory interface.

The main template methods to be implemented by subclasses are getBeanDefinition(java.lang.String) and createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[]), retrieving a bean definition for a given bean name and creating a bean instance for a given bean definition, respectively. Default implementations of those operations can be found in DefaultListableBeanFactory and AbstractAutowireCapableBeanFactory.

Since:: 15 April 2001
Author:: Rod Johnson, Juergen Hoeller
See Also:: getBeanDefinition(java.lang.String), createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[]), AbstractAutowireCapableBeanFactory.createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[]), DefaultListableBeanFactory.getBeanDefinition(java.lang.String)

Field Summary

protected Log logger
          Logger available to subclasses

Fields inherited from interface org.springframework.beans.factory.BeanFactory

FACTORY_BEAN_PREFIX

Constructor Summary

AbstractBeanFactory()
          Create a new AbstractBeanFactory.

AbstractBeanFactory(BeanFactory parentBeanFactory)
          Create a new AbstractBeanFactory with the given parent.

Method Summary

void addBeanPostProcessor(BeanPostProcessor beanPostProcessor)
          Add a new BeanPostProcessor that will get applied to beans created by this factory.

protected void addSingleton(String beanName, Object singletonObject)
          Add the given singleton object to the singleton cache of this factory.

protected void checkMergedBeanDefinition(RootBeanDefinition mergedBeanDefinition, String beanName, Class requiredType, Object[] args)
          Check the given merged bean definition, potentially throwing validation exceptions.

boolean containsBean(String name)
          Does this bean factory contain a bean with the given name?

protected abstract boolean containsBeanDefinition(String beanName)
          Check if this bean factory contains a bean definition with the given name.

boolean containsLocalBean(String name)
          Return whether the local bean factory contains a bean of the given name, ignoring beans defined in ancestor contexts.

boolean containsSingleton(String beanName)
          Check if this bean factory contains a singleton instance with the given name.

protected abstract Object createBean(String beanName, RootBeanDefinition mergedBeanDefinition, Object[] args)
          Create a bean instance for the given bean definition.

protected void destroyBean(String beanName, Object bean)
          Destroy the given bean.

void destroySingletons()
          Destroy all cached singletons in this factory.

protected Object doTypeConversionIfNecessary(Object value, Class targetType)
          Convert the given value into the specified target type, using a default BeanWrapper instance.

protected Object doTypeConversionIfNecessary(Object value, Class targetType, BeanWrapperImpl bw)
          Convert the given value into the specified target type, using the specified BeanWrapper.

String[] getAliases(String name)
          Return the aliases for the given bean name, if defined.

Object getBean(String name)
          Return an instance, which may be shared or independent, of the specified bean.

Object getBean(String name, Class requiredType)
          Return an instance, which may be shared or independent, of the specified bean.

Object getBean(String name, Class requiredType, Object[] args)
          Return an instance, which may be shared or independent, of the specified bean.

Object getBean(String name, Object[] args)
          Return an instance, which may be shared or independent, of the specified bean.

protected abstract BeanDefinition getBeanDefinition(String beanName)
          Return the bean definition for the given bean name.

int getBeanPostProcessorCount()
          Return the current number of registered BeanPostProcessors.

List getBeanPostProcessors()
          Return the list of BeanPostProcessors that will get applied to beans created with this factory.

Map getCustomEditors()
          Return the map of custom editors, with Classes as keys and PropertyEditors as values.

RootBeanDefinition getMergedBeanDefinition(String name)
          Return a RootBeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
          Return a RootBeanDefinition for the given top-level bean, by merging with the parent if the given bean's definition is a child bean definition.

protected RootBeanDefinition getMergedBeanDefinition(String name, boolean includingAncestors)
          Return a RootBeanDefinition, even by traversing parent if the parameter is a child definition.

protected Object getObjectForSharedInstance(String name, Object beanInstance)
          Get the object for the given shared bean, either the bean instance itself or its created object in case of a FactoryBean.

BeanFactory getParentBeanFactory()
          Return the parent bean factory, or null if there is none.

int getSingletonCount()
          Return the number of beans in the singleton cache.

String[] getSingletonNames()
          Return the names of beans in the singleton cache.

Class getType(String name)
          Determine the type of the bean with the given name.

protected Class getTypeForFactoryMethod(String beanName, RootBeanDefinition mergedBeanDefinition)
          Determine the bean type for the given bean definition, as far as possible.

protected boolean hasDestructionAwareBeanPostProcessors()
          Return whether this factory holds a DestructionAwareBeanPostProcessor that will get applied to singleton beans on shutdown.

protected void initBeanWrapper(BeanWrapper bw)
          Initialize the given BeanWrapper with the custom editors registered with this factory.

protected void invokeCustomDestroyMethod(String beanName, Object bean, String destroyMethodName, boolean enforceDestroyMethod)
          Invoke the specified custom destroy method on the given bean.

boolean isFactoryBean(String name)
          Determine whether the bean with the given name is a FactoryBean.

protected boolean isFactoryDereference(String name)
          Return whether the given name is a factory dereference (beginning with the factory dereference prefix).

boolean isSingleton(String name)
          Is this bean a shared singleton?

protected boolean isSingletonCurrentlyInCreation(String beanName)
          Return whether the specified singleton is currently in creation

void registerAlias(String beanName, String alias)
          Given a bean name, create an alias.

void registerCustomEditor(Class requiredType, PropertyEditor propertyEditor)
          Register the given custom property editor for all properties of the given type.

protected void registerDependentBean(String beanName, String dependentBeanName)
          Register a dependent bean for the given bean, to be destroyed before the given bean is destroyed.

protected void registerDisposableBean(String beanName, DisposableBean bean)
          Add the given bean to the list of further disposable beans in this factory.

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mergedBeanDefinition)
          Add the given bean to the list of disposable beans in this factory, registering its DisposableBean interface and/or the given destroy method to be called on factory shutdown (if applicable).

void registerSingleton(String beanName, Object singletonObject)
          Register the given existing object as singleton in the bean factory, under the given bean name.

protected void removeSingleton(String beanName)
          Remove the bean with the given name from the singleton cache of this factory.

void setParentBeanFactory(BeanFactory parentBeanFactory)
          Set the parent of this bean factory.

protected String transformedBeanName(String name)
          Return the bean name, stripping out the factory dereference prefix if necessary, and resolving aliases to canonical names.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Summary
`protected Log`	`logger` Logger available to subclasses

Fields inherited from interface org.springframework.beans.factory.BeanFactory
`FACTORY_BEAN_PREFIX`

Constructor Summary
`AbstractBeanFactory()` Create a new AbstractBeanFactory.
`AbstractBeanFactory(BeanFactory parentBeanFactory)` Create a new AbstractBeanFactory with the given parent.

Method Summary
`void`	`addBeanPostProcessor(BeanPostProcessor beanPostProcessor)` Add a new BeanPostProcessor that will get applied to beans created by this factory.
`protected void`	`addSingleton(String beanName, Object singletonObject)` Add the given singleton object to the singleton cache of this factory.
`protected void`	`checkMergedBeanDefinition(RootBeanDefinition mergedBeanDefinition, String beanName, Class requiredType, Object[] args)` Check the given merged bean definition, potentially throwing validation exceptions.
`boolean`	`containsBean(String name)` Does this bean factory contain a bean with the given name?
`protected abstract boolean`	`containsBeanDefinition(String beanName)` Check if this bean factory contains a bean definition with the given name.
`boolean`	`containsLocalBean(String name)` Return whether the local bean factory contains a bean of the given name, ignoring beans defined in ancestor contexts.
`boolean`	`containsSingleton(String beanName)` Check if this bean factory contains a singleton instance with the given name.
`protected abstract Object`	`createBean(String beanName, RootBeanDefinition mergedBeanDefinition, Object[] args)` Create a bean instance for the given bean definition.
`protected void`	`destroyBean(String beanName, Object bean)` Destroy the given bean.
`void`	`destroySingletons()` Destroy all cached singletons in this factory.
`protected Object`	`doTypeConversionIfNecessary(Object value, Class targetType)` Convert the given value into the specified target type, using a default BeanWrapper instance.
`protected Object`	`doTypeConversionIfNecessary(Object value, Class targetType, BeanWrapperImpl bw)` Convert the given value into the specified target type, using the specified BeanWrapper.
`String[]`	`getAliases(String name)` Return the aliases for the given bean name, if defined.
`Object`	`getBean(String name)` Return an instance, which may be shared or independent, of the specified bean.
`Object`	`getBean(String name, Class requiredType)` Return an instance, which may be shared or independent, of the specified bean.
`Object`	`getBean(String name, Class requiredType, Object[] args)` Return an instance, which may be shared or independent, of the specified bean.
`Object`	`getBean(String name, Object[] args)` Return an instance, which may be shared or independent, of the specified bean.
`protected abstract BeanDefinition`	`getBeanDefinition(String beanName)` Return the bean definition for the given bean name.
`int`	`getBeanPostProcessorCount()` Return the current number of registered BeanPostProcessors.
`List`	`getBeanPostProcessors()` Return the list of BeanPostProcessors that will get applied to beans created with this factory.
`Map`	`getCustomEditors()` Return the map of custom editors, with Classes as keys and PropertyEditors as values.
`RootBeanDefinition`	`getMergedBeanDefinition(String name)` Return a RootBeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.
`protected RootBeanDefinition`	`getMergedBeanDefinition(String beanName, BeanDefinition bd)` Return a RootBeanDefinition for the given top-level bean, by merging with the parent if the given bean's definition is a child bean definition.
`protected RootBeanDefinition`	`getMergedBeanDefinition(String name, boolean includingAncestors)` Return a RootBeanDefinition, even by traversing parent if the parameter is a child definition.
`protected Object`	`getObjectForSharedInstance(String name, Object beanInstance)` Get the object for the given shared bean, either the bean instance itself or its created object in case of a FactoryBean.
`BeanFactory`	`getParentBeanFactory()` Return the parent bean factory, or `null` if there is none.
`int`	`getSingletonCount()` Return the number of beans in the singleton cache.
`String[]`	`getSingletonNames()` Return the names of beans in the singleton cache.
`Class`	`getType(String name)` Determine the type of the bean with the given name.
`protected Class`	`getTypeForFactoryMethod(String beanName, RootBeanDefinition mergedBeanDefinition)` Determine the bean type for the given bean definition, as far as possible.
`protected boolean`	`hasDestructionAwareBeanPostProcessors()` Return whether this factory holds a DestructionAwareBeanPostProcessor that will get applied to singleton beans on shutdown.
`protected void`	`initBeanWrapper(BeanWrapper bw)` Initialize the given BeanWrapper with the custom editors registered with this factory.
`protected void`	`invokeCustomDestroyMethod(String beanName, Object bean, String destroyMethodName, boolean enforceDestroyMethod)` Invoke the specified custom destroy method on the given bean.
`boolean`	`isFactoryBean(String name)` Determine whether the bean with the given name is a FactoryBean.
`protected boolean`	`isFactoryDereference(String name)` Return whether the given name is a factory dereference (beginning with the factory dereference prefix).
`boolean`	`isSingleton(String name)` Is this bean a shared singleton?
`protected boolean`	`isSingletonCurrentlyInCreation(String beanName)` Return whether the specified singleton is currently in creation
`void`	`registerAlias(String beanName, String alias)` Given a bean name, create an alias.
`void`	`registerCustomEditor(Class requiredType, PropertyEditor propertyEditor)` Register the given custom property editor for all properties of the given type.
`protected void`	`registerDependentBean(String beanName, String dependentBeanName)` Register a dependent bean for the given bean, to be destroyed before the given bean is destroyed.
`protected void`	`registerDisposableBean(String beanName, DisposableBean bean)` Add the given bean to the list of further disposable beans in this factory.
`protected void`	`registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mergedBeanDefinition)` Add the given bean to the list of disposable beans in this factory, registering its DisposableBean interface and/or the given destroy method to be called on factory shutdown (if applicable).
`void`	`registerSingleton(String beanName, Object singletonObject)` Register the given existing object as singleton in the bean factory, under the given bean name.
`protected void`	`removeSingleton(String beanName)` Remove the bean with the given name from the singleton cache of this factory.
`void`	`setParentBeanFactory(BeanFactory parentBeanFactory)` Set the parent of this bean factory.
`protected String`	`transformedBeanName(String name)` Return the bean name, stripping out the factory dereference prefix if necessary, and resolving aliases to canonical names.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

logger

protected final Log logger

Logger available to subclasses

Constructor Detail

AbstractBeanFactory

public AbstractBeanFactory()

Create a new AbstractBeanFactory.

AbstractBeanFactory

public AbstractBeanFactory(BeanFactory parentBeanFactory)

Create a new AbstractBeanFactory with the given parent.

Parameters:: parentBeanFactory - parent bean factory, or null if none
See Also:: getBean(java.lang.String)

Method Detail

getBean

public Object getBean(String name)
               throws BeansException

Description copied from interface: BeanFactory

Return an instance, which may be shared or independent, of the specified bean.

This method allows a Spring BeanFactory to be used as a replacement for the Singleton or Prototype design pattern. Callers may retain references to returned objects in the case of Singleton beans.

Translates aliases back to the corresponding canonical bean name. Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:: getBean in interface BeanFactory

Parameters:: name - the name of the bean to retrieve
Returns:: an instance of the bean
Throws:: NoSuchBeanDefinitionException - if there is no bean definition with the specified name; BeansException - if the bean could not be obtained

getBean

public Object getBean(String name,
                      Class requiredType)
               throws BeansException

Description copied from interface: BeanFactory

Return an instance, which may be shared or independent, of the specified bean.

Behaves the same as BeanFactory.getBean(String), but provides a measure of type safety by throwing a BeanNotOfRequiredTypeException if the bean is not of the required type. This means that ClassCastException can't be thrown on casting the result correctly, as can happen with BeanFactory.getBean(String).

Translates aliases back to the corresponding canonical bean name. Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:: getBean in interface BeanFactory

Parameters:: name - the name of the bean to retrieve; requiredType - type the bean must match. Can be an interface or superclass of the actual class, or null for any match. For example, if the value is Object.class, this method will succeed whatever the class of the returned instance.
Returns:: an instance of the bean
Throws:: BeanNotOfRequiredTypeException - if the bean is not of the required type; NoSuchBeanDefinitionException - if there's no such bean definition; BeansException - if the bean could not be created

getBean

public Object getBean(String name,
                      Object[] args)
               throws BeansException

Return an instance, which may be shared or independent, of the specified bean.

Parameters:: name - the name of the bean to retrieve; args - arguments to use if creating a prototype using explicit arguments to a static factory method. It is invalid to use a non-null args value in any other case.
Returns:: an instance of the bean
Throws:: BeansException - if the bean could not be created

getBean

public Object getBean(String name,
                      Class requiredType,
                      Object[] args)
               throws BeansException

Return an instance, which may be shared or independent, of the specified bean.

Parameters:: name - the name of the bean to retrieve; requiredType - the required type of the bean to retrieve; args - arguments to use if creating a prototype using explicit arguments to a static factory method. It is invalid to use a non-null args value in any other case.
Returns:: an instance of the bean
Throws:: BeansException - if the bean could not be created

containsBean

public boolean containsBean(String name)

Description copied from interface: BeanFactory

Does this bean factory contain a bean with the given name?

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:: containsBean in interface BeanFactory

Parameters:: name - the name of the bean to query
Returns:: whether a bean with the given name is defined

isSingleton

public boolean isSingleton(String name)
                    throws NoSuchBeanDefinitionException

Description copied from interface: BeanFactory

Is this bean a shared singleton? That is, will BeanFactory.getBean(java.lang.String) always return the same instance?

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:: isSingleton in interface BeanFactory

Parameters:: name - the name of the bean to query
Returns:: whether this bean corresponds to a singleton instance
Throws:: NoSuchBeanDefinitionException - if there is no bean with the given name
See Also:: BeanFactory.getBean(java.lang.String)

getType

public Class getType(String name)
              throws NoSuchBeanDefinitionException

Description copied from interface: BeanFactory

Determine the type of the bean with the given name. More specifically, check the type of object that BeanFactory.getBean(java.lang.String) would return. For a FactoryBean, return the type of object that the FactoryBean creates.

Specified by:: getType in interface BeanFactory

Parameters:: name - the name of the bean to query
Returns:: the type of the bean, or null if not determinable
Throws:: NoSuchBeanDefinitionException - if there is no bean with the given name
See Also:: BeanFactory.getBean(java.lang.String), FactoryBean.getObjectType()

getAliases

public String[] getAliases(String name)
                    throws NoSuchBeanDefinitionException

Description copied from interface: BeanFactory

Return the aliases for the given bean name, if defined.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:: getAliases in interface BeanFactory

Parameters:: name - the bean name to check for aliases
Returns:: the aliases, or an empty array if none
Throws:: NoSuchBeanDefinitionException - if there is no bean definition with the specified name

getParentBeanFactory

public BeanFactory getParentBeanFactory()

Description copied from interface: HierarchicalBeanFactory

Return the parent bean factory, or null if there is none.

Specified by:: getParentBeanFactory in interface HierarchicalBeanFactory

containsLocalBean

public boolean containsLocalBean(String name)

Description copied from interface: HierarchicalBeanFactory

Return whether the local bean factory contains a bean of the given name, ignoring beans defined in ancestor contexts.

This is an alternative to containsBean, ignoring a bean of the given name from an ancestor bean factory.

Specified by:: containsLocalBean in interface HierarchicalBeanFactory

Parameters:: name - the name of the bean to query
Returns:: whether a bean with the given name is defined in the local factory
See Also:: BeanFactory.containsBean(java.lang.String)

setParentBeanFactory

public void setParentBeanFactory(BeanFactory parentBeanFactory)

Description copied from interface: ConfigurableBeanFactory

Set the parent of this bean factory.

Note that the parent shouldn't be changed: It should only be set outside a constructor if it isn't available when an object of this class is created.

Specified by:: setParentBeanFactory in interface ConfigurableBeanFactory

Parameters:: parentBeanFactory - the parent bean factory

registerCustomEditor

public void registerCustomEditor(Class requiredType,
                                 PropertyEditor propertyEditor)

Description copied from interface: ConfigurableBeanFactory

Register the given custom property editor for all properties of the given type. To be invoked during factory configuration.

Specified by:: registerCustomEditor in interface ConfigurableBeanFactory

Parameters:: requiredType - type of the property; propertyEditor - editor to register

getCustomEditors

public Map getCustomEditors()

Return the map of custom editors, with Classes as keys and PropertyEditors as values.

addBeanPostProcessor

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor)

Description copied from interface: ConfigurableBeanFactory

Add a new BeanPostProcessor that will get applied to beans created by this factory. To be invoked during factory configuration.

Specified by:: addBeanPostProcessor in interface ConfigurableBeanFactory

Parameters:: beanPostProcessor - the bean processor to register

getBeanPostProcessorCount

public int getBeanPostProcessorCount()

Description copied from interface: ConfigurableBeanFactory

Return the current number of registered BeanPostProcessors.

Specified by:: getBeanPostProcessorCount in interface ConfigurableBeanFactory

getBeanPostProcessors

public List getBeanPostProcessors()

Return the list of BeanPostProcessors that will get applied to beans created with this factory.

hasDestructionAwareBeanPostProcessors

protected boolean hasDestructionAwareBeanPostProcessors()

Return whether this factory holds a DestructionAwareBeanPostProcessor that will get applied to singleton beans on shutdown.

See Also:: addBeanPostProcessor(org.springframework.beans.factory.config.BeanPostProcessor), DestructionAwareBeanPostProcessor

registerAlias

public void registerAlias(String beanName,
                          String alias)
                   throws BeanDefinitionStoreException

Description copied from interface: ConfigurableBeanFactory

Given a bean name, create an alias. We typically use this method to support names that are illegal within XML ids (used for bean names).

Typically invoked during factory configuration, but can also be used for runtime registration of aliases. Therefore, a factory implementation should synchronize alias access.

Specified by:: registerAlias in interface ConfigurableBeanFactory

Parameters:: beanName - name of the bean; alias - alias that will behave the same as the bean name
Throws:: BeanDefinitionStoreException

registerSingleton

public void registerSingleton(String beanName,
                              Object singletonObject)
                       throws BeanDefinitionStoreException

Description copied from interface: ConfigurableBeanFactory

The given instance is supposed to be fully initialized; the factory will not perform any initialization callbacks (in particular, it won't call InitializingBean's afterPropertiesSet method). The given instance will not receive any destruction callbacks (like DisposableBean's destroy method) either.

Register a bean definition instead of an existing instance if your bean is supposed to receive initialization and/or destruction callbacks.

Typically invoked during factory configuration, but can also be used for runtime registration of singletons. Therefore, a factory implementation should synchronize singleton access; it will have to do this anyway if it supports lazy initialization of singletons.

Specified by:: registerSingleton in interface ConfigurableBeanFactory

Parameters:: beanName - name of the bean; singletonObject - the existing object
Throws:: BeanDefinitionStoreException
See Also:: InitializingBean.afterPropertiesSet(), DisposableBean.destroy(), DefaultListableBeanFactory.registerBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition)

addSingleton

protected void addSingleton(String beanName,
                            Object singletonObject)

Add the given singleton object to the singleton cache of this factory.

To be called for eager registration of singletons, e.g. to be able to resolve circular references.

Parameters:: beanName - the name of the bean; singletonObject - the singleton object

removeSingleton

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

Parameters:: beanName - the name of the bean

getSingletonCount

public int getSingletonCount()

Return the number of beans in the singleton cache.

Does not consider any hierarchy this factory may participate in.

getSingletonNames

public String[] getSingletonNames()

Return the names of beans in the singleton cache.

Does not consider any hierarchy this factory may participate in.

isSingletonCurrentlyInCreation

protected boolean isSingletonCurrentlyInCreation(String beanName)

Return whether the specified singleton is currently in creation

Parameters:: beanName - the name of the bean

containsSingleton

public boolean containsSingleton(String beanName)

Description copied from interface: ConfigurableBeanFactory

Check if this bean factory contains a singleton instance with the given name. Only checks already instantiated singletons; does not return true for singleton bean definitions that have not been instantiated yet.

The main purpose of this method is to check manually registered singletons (see registerSingleton). Can also be used to check whether a singleton defined by a bean definition has already been created.

To check whether a bean factory contains a bean definition with a given name, use ListableBeanFactory's containsBeanDefinition. Analogous to the present method, this checks whether the factory contains a registered bean definition. Note that both of those methods check for the actual given bean name, ignoring aliases.

Use BeanFactory's containsBean for general checks whether the factory knows about a bean with a given name (whether manually registed singleton instance or created by bean definition), also checking ancestor factories. To check the local factory only, use HierarchicalBeanFactory's containsLocalBean. Both of those methods translate aliases back to the corresponding canonical bean name.

Specified by:: containsSingleton in interface ConfigurableBeanFactory

Parameters:: beanName - the name of the bean to look for
Returns:: if this bean factory contains a singleton instance with the given name
See Also:: ConfigurableBeanFactory.registerSingleton(java.lang.String, java.lang.Object), BeanFactory.containsBean(java.lang.String), HierarchicalBeanFactory.containsLocalBean(java.lang.String), ListableBeanFactory.containsBeanDefinition(java.lang.String)

destroySingletons

public void destroySingletons()

Description copied from interface: ConfigurableBeanFactory

Destroy all cached singletons in this factory. To be called on shutdown of a factory.

Specified by:: destroySingletons in interface ConfigurableBeanFactory

isFactoryDereference

protected boolean isFactoryDereference(String name)

Return whether the given name is a factory dereference (beginning with the factory dereference prefix).

See Also:: BeanFactory.FACTORY_BEAN_PREFIX, BeanFactoryUtils.isFactoryDereference(java.lang.String)

transformedBeanName

protected String transformedBeanName(String name)

Return the bean name, stripping out the factory dereference prefix if necessary, and resolving aliases to canonical names.

initBeanWrapper

protected void initBeanWrapper(BeanWrapper bw)

Initialize the given BeanWrapper with the custom editors registered with this factory. To be called for BeanWrappers that will create and populate bean instances.

Parameters:: bw - the BeanWrapper to initialize

doTypeConversionIfNecessary

protected Object doTypeConversionIfNecessary(Object value,
                                             Class targetType)
                                      throws TypeMismatchException

Convert the given value into the specified target type, using a default BeanWrapper instance.

Parameters:: value - the original value; targetType - the target type
Returns:: the converted value, matching the target type
Throws:: TypeMismatchException - if type conversion failed
See Also:: doTypeConversionIfNecessary(Object, Class, org.springframework.beans.BeanWrapperImpl)

doTypeConversionIfNecessary

protected Object doTypeConversionIfNecessary(Object value,
                                             Class targetType,
                                             BeanWrapperImpl bw)
                                      throws TypeMismatchException

Convert the given value into the specified target type, using the specified BeanWrapper.

Parameters:: value - the original value; targetType - the target type; bw - the BeanWrapper to work on
Returns:: the converted value, matching the target type
Throws:: TypeMismatchException - if type conversion failed
See Also:: BeanWrapperImpl.doTypeConversionIfNecessary(Object, Class)

getMergedBeanDefinition

public RootBeanDefinition getMergedBeanDefinition(String name)
                                           throws BeansException

Return a RootBeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.

Parameters:: name - the name of the bean to retrieve the merged definition for
Returns:: a (potentially merged) RootBeanDefinition for the given bean
Throws:: NoSuchBeanDefinitionException - if there is no bean with the given name; BeansException - in case of errors

getMergedBeanDefinition

protected RootBeanDefinition getMergedBeanDefinition(String name,
                                                     boolean includingAncestors)
                                              throws BeansException

Return a RootBeanDefinition, even by traversing parent if the parameter is a child definition. Can ask the parent bean factory if not found in this instance.

Parameters:: name - the name of the bean to retrieve the merged definition for; includingAncestors - whether to ask the parent bean factory if not found in this instance
Returns:: a (potentially merged) RootBeanDefinition for the given bean
Throws:: NoSuchBeanDefinitionException - if there is no bean with the given name; BeanDefinitionStoreException - in case of an invalid bean definition; BeansException

getMergedBeanDefinition

protected RootBeanDefinition getMergedBeanDefinition(String beanName,
                                                     BeanDefinition bd)
                                              throws BeanDefinitionStoreException

Return a RootBeanDefinition for the given top-level bean, by merging with the parent if the given bean's definition is a child bean definition.

Parameters:: beanName - the name of the bean definition; bd - the original bean definition (Root/ChildBeanDefinition)
Returns:: a (potentially merged) RootBeanDefinition for the given bean
Throws:: BeanDefinitionStoreException - in case of an invalid bean definition

checkMergedBeanDefinition

protected void checkMergedBeanDefinition(RootBeanDefinition mergedBeanDefinition,
                                         String beanName,
                                         Class requiredType,
                                         Object[] args)
                                  throws BeansException

Check the given merged bean definition, potentially throwing validation exceptions.

Parameters:: mergedBeanDefinition - the bean definition to check; beanName - the name of the bean; requiredType - the required type of the bean; args - the arguments for bean creation, if any
Throws:: BeansException - in case of validation failure

getObjectForSharedInstance

protected Object getObjectForSharedInstance(String name,
                                            Object beanInstance)
                                     throws BeansException

Get the object for the given shared bean, either the bean instance itself or its created object in case of a FactoryBean.

Parameters:: name - name that may include factory dereference prefix; beanInstance - the shared bean instance
Returns:: the singleton instance of the bean
Throws:: BeansException

isFactoryBean

public boolean isFactoryBean(String name)
                      throws NoSuchBeanDefinitionException

Determine whether the bean with the given name is a FactoryBean.

Parameters:: name - the name of the bean to check
Throws:: NoSuchBeanDefinitionException - if there is no bean with the given name

registerDisposableBeanIfNecessary

protected void registerDisposableBeanIfNecessary(String beanName,
                                                 Object bean,
                                                 RootBeanDefinition mergedBeanDefinition)

Add the given bean to the list of disposable beans in this factory, registering its DisposableBean interface and/or the given destroy method to be called on factory shutdown (if applicable). Only applies to singletons.

Also registers bean as dependent on other beans, according to the "depends-on" configuration in the bean definition.

Parameters:: beanName - the name of the bean; bean - the bean instance; mergedBeanDefinition - the bean definition for the bean
See Also:: AbstractBeanDefinition.isSingleton(), AbstractBeanDefinition.getDependsOn(), registerDisposableBean(java.lang.String, org.springframework.beans.factory.DisposableBean), registerDependentBean(java.lang.String, java.lang.String)

registerDisposableBean

protected void registerDisposableBean(String beanName,
                                      DisposableBean bean)

Add the given bean to the list of further disposable beans in this factory.

Parameters:: beanName - the name of the bean; bean - the bean instance

registerDependentBean

protected void registerDependentBean(String beanName,
                                     String dependentBeanName)

Parameters:: beanName - the name of the bean; dependentBeanName - the name of the dependent bean

destroyBean

protected void destroyBean(String beanName,
                           Object bean)

Destroy the given bean. Must destroy beans that depend on the given bean before the bean itself. Should not throw any exceptions.

Parameters:: beanName - name of the bean; bean - the bean instance to destroy

invokeCustomDestroyMethod

protected void invokeCustomDestroyMethod(String beanName,
                                         Object bean,
                                         String destroyMethodName,
                                         boolean enforceDestroyMethod)

Invoke the specified custom destroy method on the given bean.

This implementation invokes a no-arg method if found, else checking for a method with a single boolean argument (passing in "true", assuming a "force" parameter), else logging an error.

Can be overridden in subclasses for custom resolution of destroy methods with arguments.

Parameters:: beanName - the bean has in the factory. Used for debug output.; bean - new bean instance we may need to notify of destruction; destroyMethodName - the name of the custom destroy method; enforceDestroyMethod - indicates whether the defined destroy method needs to exist

containsBeanDefinition

protected abstract boolean containsBeanDefinition(String beanName)

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
See Also:: containsBean(java.lang.String), ListableBeanFactory.containsBeanDefinition(java.lang.String)

getBeanDefinition

protected abstract BeanDefinition getBeanDefinition(String beanName)
                                             throws BeansException

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.

Parameters:: beanName - the name of the bean to find a definition for
Returns:: the BeanDefinition for this prototype name (never null)
Throws:: NoSuchBeanDefinitionException - if the bean definition cannot be resolved; BeansException - in case of errors
See Also:: RootBeanDefinition, ChildBeanDefinition, ConfigurableListableBeanFactory.getBeanDefinition(java.lang.String)

createBean

protected abstract Object createBean(String beanName,
                                     RootBeanDefinition mergedBeanDefinition,
                                     Object[] args)
                              throws BeanCreationException

Create a bean instance for the given bean definition. The bean definition will already have been merged with the parent definition in case of a child definition.

All the other methods in this class invoke this method, although beans may be cached after being instantiated by this method. All bean instantiation within this class is performed by this method.

Parameters:: beanName - the name of the bean; mergedBeanDefinition - the bean definition for the bean; args - arguments to use if creating a prototype using explicit arguments to a static factory method. This parameter must be null except in this case.
Returns:: a new instance of the bean
Throws:: BeanCreationException - if the bean could not be created

getTypeForFactoryMethod

protected Class getTypeForFactoryMethod(String beanName,
                                        RootBeanDefinition mergedBeanDefinition)

Determine the bean type for the given bean definition, as far as possible.

Default implementation returns null to indicate that the type cannot be determined. Subclasses are encouraged to try to determine the actual return type here, matching their strategy of resolving factory methods in the createBean implementation.

Parameters:: beanName - name of the bean; mergedBeanDefinition - the bean definition for the bean
Returns:: the type for the bean if determinable, or null else
See Also:: createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

AbstractBeanFactory (Spring Framework) - Spring Framework 1.2.9 API 文档英文版

org.springframework.beans.factory.support Class AbstractBeanFactory

logger

AbstractBeanFactory

AbstractBeanFactory

getBean

getBean

getBean

getBean

containsBean

isSingleton

getType

getAliases

getParentBeanFactory

containsLocalBean

setParentBeanFactory

registerCustomEditor

getCustomEditors

addBeanPostProcessor

getBeanPostProcessorCount

getBeanPostProcessors

hasDestructionAwareBeanPostProcessors

registerAlias

registerSingleton

addSingleton

removeSingleton

getSingletonCount

getSingletonNames

isSingletonCurrentlyInCreation

containsSingleton

destroySingletons

isFactoryDereference

transformedBeanName

initBeanWrapper

doTypeConversionIfNecessary

doTypeConversionIfNecessary

getMergedBeanDefinition

getMergedBeanDefinition

getMergedBeanDefinition

checkMergedBeanDefinition

getObjectForSharedInstance

isFactoryBean

registerDisposableBeanIfNecessary

registerDisposableBean

registerDependentBean

destroyBean

invokeCustomDestroyMethod

containsBeanDefinition

getBeanDefinition

createBean

getTypeForFactoryMethod

org.springframework.beans.factory.support
Class AbstractBeanFactory