| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectorg.springframework.core.SimpleAliasRegistry
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
org.springframework.beans.factory.support.FactoryBeanRegistrySupport
org.springframework.beans.factory.support.AbstractBeanFactory
public abstract class AbstractBeanFactory
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 a singleton cache (through its base class
 DefaultSingletonBeanRegistry,
 singleton/prototype determination, 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.
getBeanDefinition(java.lang.String), 
createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[]), 
AbstractAutowireCapableBeanFactory.createBean(java.lang.Class), 
DefaultListableBeanFactory.getBeanDefinition(java.lang.String)| Field Summary | 
|---|
| Fields inherited from class org.springframework.beans.factory.support.DefaultSingletonBeanRegistry | 
|---|
| logger, NULL_OBJECT | 
| Fields inherited from interface org.springframework.beans.factory.config.ConfigurableBeanFactory | 
|---|
| SCOPE_PROTOTYPE, SCOPE_SINGLETON | 
| 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. | 
|  void | addPropertyEditorRegistrar(PropertyEditorRegistrar registrar)Add a PropertyEditorRegistrar to be applied to all bean creation processes. | 
| protected  void | afterPrototypeCreation(String beanName)Callback after prototype creation. | 
| protected  void | beforePrototypeCreation(String beanName)Callback before prototype creation. | 
| protected  void | checkMergedBeanDefinition(RootBeanDefinition mbd,
                          String beanName,
                          Object[] args)Check the given merged bean definition, potentially throwing validation exceptions. | 
| protected  void | clearMergedBeanDefinition(String beanName)Remove the merged bean definition for the specified bean, recreating it on next access. | 
|  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. | 
|  void | copyConfigurationFrom(ConfigurableBeanFactory otherFactory)Copy all relevant configuration from the given other factory. | 
|  void | copyRegisteredEditorsTo(PropertyEditorRegistry registry)Initialize the given PropertyEditorRegistry with the custom editors that have been registered with this BeanFactory. | 
| protected abstract  Object | createBean(String beanName,
           RootBeanDefinition mbd,
           Object[] args)Create a bean instance for the given bean definition. | 
|  void | destroyBean(String beanName,
            Object beanInstance)Destroy the given bean instance (usually a prototype instance obtained from this factory) according to its bean definition. | 
| protected  void | destroyBean(String beanName,
            Object beanInstance,
            RootBeanDefinition mbd)Destroy the given bean instance (usually a prototype instance obtained from this factory) according to the given bean definition. | 
|  void | destroyScopedBean(String beanName)Destroy the specified scoped bean in the current target scope, if any. | 
| protected  Object | doGetBean(String name,
          Class requiredType,
          Object[] args,
          boolean typeCheckOnly)Return an instance, which may be shared or independent, of the specified bean. | 
|  String[] | getAliases(String name)Return the aliases for the given 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. | 
|  ClassLoader | getBeanClassLoader()Return this factory's class loader for loading bean classes. | 
| protected abstract  BeanDefinition | getBeanDefinition(String beanName)Return the bean definition for the given bean name. | 
|  int | getBeanPostProcessorCount()Return the current number of registered BeanPostProcessors, if any. | 
|  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 PropertyEditor instances or PropertyEditor classes as values. | 
| protected  TypeConverter | getCustomTypeConverter()Return the custom TypeConverter to use, if any. | 
|  BeanDefinition | getMergedBeanDefinition(String name)Return a 'merged' BeanDefinition 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 beanName,
                        BeanDefinition bd,
                        BeanDefinition containingBd)Return a RootBeanDefinition for the given bean, by merging with the parent if the given bean's definition is a child bean definition. | 
| protected  RootBeanDefinition | getMergedLocalBeanDefinition(String beanName)Return a merged RootBeanDefinition, traversing the parent bean definition if the specified bean corresponds to a child bean definition. | 
| protected  Object | getObjectForBeanInstance(Object beanInstance,
                         String name,
                         String beanName,
                         RootBeanDefinition mbd)Get the object for the given bean instance, either the bean instance itself or its created object in case of a FactoryBean. | 
|  BeanFactory | getParentBeanFactory()Return the parent bean factory, or nullif there is none. | 
|  Set | getPropertyEditorRegistrars()Return the set of PropertyEditorRegistrars. | 
|  Scope | getRegisteredScope(String scopeName)Return the Scope implementation for the given scope name, if any. | 
|  String[] | getRegisteredScopeNames()Return the names of all currently registered scopes. | 
|  ClassLoader | getTempClassLoader()Return the temporary ClassLoader to use for type matching purposes, if any. | 
|  Class | getType(String name)Determine the type of the bean with the given name. | 
|  TypeConverter | getTypeConverter()Obtain a type converter as used by this BeanFactory. | 
| protected  Class | getTypeForFactoryBean(String beanName,
                      RootBeanDefinition mbd)Determine the bean type for the given FactoryBean 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  boolean | hasInstantiationAwareBeanPostProcessors()Return whether this factory holds a InstantiationAwareBeanPostProcessor 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  boolean | isBeanEligibleForMetadataCaching(String beanName)Determine whether the specified bean is eligible for having its bean definition metadata cached. | 
|  boolean | isBeanNameInUse(String beanName)Determine whether the given bean name is already in use within this factory, i.e. whether there is a local bean or alias registered under this name or an inner bean created with this name. | 
|  boolean | isCacheBeanMetadata()Return whether to cache bean metadata such as given bean definitions (in merged fashion) and resolved bean classes. | 
|  boolean | isCurrentlyInCreation(String beanName)Determine whether the specified bean is currently in creation. | 
|  boolean | isFactoryBean(String name)Determine whether the bean with the given name is a FactoryBean. | 
| protected  boolean | isFactoryBean(String beanName,
              RootBeanDefinition mbd)Check whether the given bean is defined as a FactoryBean. | 
|  boolean | isPrototype(String name)Is this bean a prototype? | 
| protected  boolean | isPrototypeCurrentlyInCreation(String beanName)Return whether the specified prototype bean is currently in creation (within the current thread). | 
|  boolean | isSingleton(String name)Is this bean a shared singleton? | 
|  boolean | isTypeMatch(String name,
            Class targetType)Check whether the bean with the given name matches the specified type. | 
| protected  void | markBeanAsCreated(String beanName)Mark the specified bean as already created (or about to be created). | 
| protected  String | originalBeanName(String name)Determine the original bean name, resolving locally defined aliases to canonical names. | 
| protected  Class | predictBeanType(String beanName,
                RootBeanDefinition mbd,
                Class[] typesToMatch)Predict the eventual bean type (of the processed bean instance) for the specified bean. | 
|  void | registerCustomEditor(Class requiredType,
                     Class propertyEditorClass)Register the given custom property editor for all properties of the given type. | 
|  void | registerCustomEditor(Class requiredType,
                     PropertyEditor propertyEditor)Register the given custom property editor for all properties of the given type. | 
| protected  void | registerCustomEditors(PropertyEditorRegistry registry)Initialize the given PropertyEditorRegistry with the custom editors that have been registered with this BeanFactory. | 
| protected  void | registerDisposableBeanIfNecessary(String beanName,
                                  Object bean,
                                  RootBeanDefinition mbd)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 | registerScope(String scopeName,
              Scope scope)Register the given scope, backed by the given Scope implementation. | 
| protected  boolean | removeSingletonIfCreatedForTypeCheckOnly(String beanName)Remove the singleton instance (if any) for the given bean name, but only if it hasn't been used for other purposes than type checking. | 
| protected  boolean | requiresDestruction(Object bean,
                    RootBeanDefinition mbd)Determine whether the given bean requires destruction on shutdown. | 
| protected  Class | resolveBeanClass(RootBeanDefinition mbd,
                 String beanName)Resolve the bean class for the specified bean definition, resolving a bean class name into a Class reference (if necessary) and storing the resolved Class in the bean definition for further use. | 
| protected  Class | resolveBeanClass(RootBeanDefinition mbd,
                 String beanName,
                 Class[] typesToMatch)Resolve the bean class for the specified bean definition, resolving a bean class name into a Class reference (if necessary) and storing the resolved Class in the bean definition for further use. | 
|  void | setBeanClassLoader(ClassLoader beanClassLoader)Set the class loader to use for loading bean classes. | 
|  void | setCacheBeanMetadata(boolean cacheBeanMetadata)Set whether to cache bean metadata such as given bean definitions (in merged fashion) and resolved bean classes. | 
|  void | setParentBeanFactory(BeanFactory parentBeanFactory)Set the parent of this bean factory. | 
|  void | setTempClassLoader(ClassLoader tempClassLoader)Specify a temporary ClassLoader to use for type matching purposes. | 
|  void | setTypeConverter(TypeConverter typeConverter)Set a custom type converter that this BeanFactory should use for converting bean property values, constructor argument values, etc. | 
| 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 org.springframework.beans.factory.support.FactoryBeanRegistrySupport | 
|---|
| getCachedObjectForFactoryBean, getFactoryBean, getObjectFromFactoryBean, getTypeForFactoryBean, postProcessObjectFromFactoryBean, removeSingleton | 
| Methods inherited from class org.springframework.beans.factory.support.DefaultSingletonBeanRegistry | 
|---|
| addSingleton, addSingletonFactory, afterSingletonCreation, beforeSingletonCreation, containsSingleton, destroyBean, destroySingleton, destroySingletons, getDependenciesForBean, getDependentBeans, getSingleton, getSingleton, getSingleton, getSingletonCount, getSingletonMutex, getSingletonNames, hasDependentBean, isSingletonCurrentlyInCreation, onSuppressedException, registerContainedBean, registerDependentBean, registerDisposableBean, registerSingleton | 
| Methods inherited from class org.springframework.core.SimpleAliasRegistry | 
|---|
| allowAliasOverriding, canonicalName, isAlias, registerAlias, removeAlias, resolveAliases | 
| Methods inherited from class java.lang.Object | 
|---|
| clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait | 
| Methods inherited from interface org.springframework.beans.factory.config.ConfigurableBeanFactory | 
|---|
| destroySingletons, getDependenciesForBean, getDependentBeans, registerAlias, registerDependentBean, resolveAliases | 
| Methods inherited from interface org.springframework.beans.factory.config.SingletonBeanRegistry | 
|---|
| containsSingleton, getSingleton, getSingletonCount, getSingletonNames, registerSingleton | 
| Constructor Detail | 
|---|
public AbstractBeanFactory()
public AbstractBeanFactory(BeanFactory parentBeanFactory)
parentBeanFactory - parent bean factory, or null if nonegetBean(java.lang.String)| Method Detail | 
|---|
public Object getBean(String name)
               throws BeansException
BeanFactoryThis 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.
getBean in interface BeanFactoryname - the name of the bean to retrieve
NoSuchBeanDefinitionException - if there is no bean definition
 with the specified name
BeansException - if the bean could not be obtained
public Object getBean(String name,
                      Class requiredType)
               throws BeansException
BeanFactoryBehaves 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.
getBean in interface BeanFactoryname - the name of the bean to retrieverequiredType - 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.
NoSuchBeanDefinitionException - if there's no such bean definition
BeanNotOfRequiredTypeException - if the bean is not of the required type
BeansException - if the bean could not be created
public Object getBean(String name,
                      Object[] args)
               throws BeansException
BeanFactoryAllows for specifying explicit constructor arguments / factory method arguments, overriding the specified default arguments (if any) in the bean definition.
getBean in interface BeanFactoryname - the name of the bean to retrieveargs - 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.
NoSuchBeanDefinitionException - if there's no such bean definition
BeanDefinitionStoreException - if arguments have been given but
 the affected bean isn't a prototype
BeansException - if the bean could not be created
public Object getBean(String name,
                      Class requiredType,
                      Object[] args)
               throws BeansException
name - the name of the bean to retrieverequiredType - the required type of the bean to retrieveargs - 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.
BeansException - if the bean could not be created
protected Object doGetBean(String name,
                           Class requiredType,
                           Object[] args,
                           boolean typeCheckOnly)
                    throws BeansException
name - the name of the bean to retrieverequiredType - the required type of the bean to retrieveargs - 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.typeCheckOnly - whether the instance is obtained for a type check,
 not for actual use
BeansException - if the bean could not be createdpublic boolean containsBean(String name)
BeanFactoryBeanFactory.getBean(java.lang.String) able to obtain a bean instance for the given name?
 Translates aliases back to the corresponding canonical bean name. Will ask the parent factory if the bean cannot be found in this factory instance.
containsBean in interface BeanFactoryname - the name of the bean to query
public boolean isSingleton(String name)
                    throws NoSuchBeanDefinitionException
BeanFactoryBeanFactory.getBean(java.lang.String) always
 return the same instance?
 Note: This method returning false does not clearly indicate
 independent instances. It indicates non-singleton instances, which may correspond
 to a scoped bean as well. Use the BeanFactory.isPrototype(java.lang.String) operation to explicitly
 check for independent instances.
 
Translates aliases back to the corresponding canonical bean name. Will ask the parent factory if the bean cannot be found in this factory instance.
isSingleton in interface BeanFactoryname - the name of the bean to query
NoSuchBeanDefinitionException - if there is no bean with the given nameBeanFactory.getBean(java.lang.String), 
BeanFactory.isPrototype(java.lang.String)
public boolean isPrototype(String name)
                    throws NoSuchBeanDefinitionException
BeanFactoryBeanFactory.getBean(java.lang.String) always return
 independent instances?
 Note: This method returning false does not clearly indicate
 a singleton object. It indicates non-independent instances, which may correspond
 to a scoped bean as well. Use the BeanFactory.isSingleton(java.lang.String) operation to explicitly
 check for a shared singleton instance.
 
Translates aliases back to the corresponding canonical bean name. Will ask the parent factory if the bean cannot be found in this factory instance.
isPrototype in interface BeanFactoryname - the name of the bean to query
NoSuchBeanDefinitionException - if there is no bean with the given nameBeanFactory.getBean(java.lang.String), 
BeanFactory.isSingleton(java.lang.String)
public boolean isTypeMatch(String name,
                           Class targetType)
                    throws NoSuchBeanDefinitionException
BeanFactoryBeanFactory.getBean(java.lang.String) call for the given name
 would return an object that is assignable to the specified target type.
 Translates aliases back to the corresponding canonical bean name. Will ask the parent factory if the bean cannot be found in this factory instance.
isTypeMatch in interface BeanFactoryname - the name of the bean to querytargetType - the type to match against
true if the bean type matches,
 false if it doesn't match or cannot be determined yet
NoSuchBeanDefinitionException - if there is no bean with the given nameBeanFactory.getBean(java.lang.String), 
BeanFactory.getType(java.lang.String)
public Class getType(String name)
              throws NoSuchBeanDefinitionException
BeanFactoryBeanFactory.getBean(java.lang.String) would return for the given name.
 For a FactoryBean, return the type of object that the FactoryBean creates,
 as exposed by FactoryBean.getObjectType().
 
Translates aliases back to the corresponding canonical bean name. Will ask the parent factory if the bean cannot be found in this factory instance.
getType in interface BeanFactoryname - the name of the bean to query
null if not determinable
NoSuchBeanDefinitionException - if there is no bean with the given nameBeanFactory.getBean(java.lang.String), 
BeanFactory.isTypeMatch(java.lang.String, java.lang.Class)public String[] getAliases(String name)
AliasRegistry
getAliases in interface BeanFactorygetAliases in interface AliasRegistrygetAliases in class SimpleAliasRegistryname - the name to check for aliases
BeanFactory.getBean(java.lang.String)public BeanFactory getParentBeanFactory()
HierarchicalBeanFactorynull if there is none.
getParentBeanFactory in interface HierarchicalBeanFactorypublic boolean containsLocalBean(String name)
HierarchicalBeanFactoryThis is an alternative to containsBean, ignoring a bean
 of the given name from an ancestor bean factory.
containsLocalBean in interface HierarchicalBeanFactoryname - the name of the bean to query
BeanFactory.containsBean(java.lang.String)public void setParentBeanFactory(BeanFactory parentBeanFactory)
ConfigurableBeanFactoryNote that the parent cannot be changed: It should only be set outside a constructor if it isn't available at the time of factory instantiation.
setParentBeanFactory in interface ConfigurableBeanFactoryparentBeanFactory - the parent BeanFactoryHierarchicalBeanFactory.getParentBeanFactory()public void setBeanClassLoader(ClassLoader beanClassLoader)
ConfigurableBeanFactoryNote that this class loader will only apply to bean definitions that do not carry a resolved bean class yet. This is the case as of Spring 2.0 by default: Bean definitions only carry bean class names, to be resolved once the factory processes the bean definition.
setBeanClassLoader in interface ConfigurableBeanFactorybeanClassLoader - the class loader to use,
 or null to suggest the default class loaderpublic ClassLoader getBeanClassLoader()
ConfigurableBeanFactory
getBeanClassLoader in interface ConfigurableBeanFactorypublic void setTempClassLoader(ClassLoader tempClassLoader)
ConfigurableBeanFactoryA temporary ClassLoader is usually just specified if load-time weaving is involved, to make sure that actual bean classes are loaded as lazily as possible. The temporary loader is then removed once the BeanFactory completes its bootstrap phase.
setTempClassLoader in interface ConfigurableBeanFactorypublic ClassLoader getTempClassLoader()
ConfigurableBeanFactory
getTempClassLoader in interface ConfigurableBeanFactorypublic void setCacheBeanMetadata(boolean cacheBeanMetadata)
ConfigurableBeanFactoryTurn this flag off to enable hot-refreshing of bean definition objects and in particular bean classes. If this flag is off, any creation of a bean instance will re-query the bean class loader for newly resolved classes.
setCacheBeanMetadata in interface ConfigurableBeanFactorypublic boolean isCacheBeanMetadata()
ConfigurableBeanFactory
isCacheBeanMetadata in interface ConfigurableBeanFactorypublic void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar)
ConfigurableBeanFactorySuch a registrar creates new PropertyEditor instances and registers them
 on the given registry, fresh for each bean creation attempt. This avoids
 the need for synchronization on custom editors; hence, it is generally
 preferable to use this method instead of ConfigurableBeanFactory.registerCustomEditor(java.lang.Class, java.lang.Class).
addPropertyEditorRegistrar in interface ConfigurableBeanFactoryregistrar - the PropertyEditorRegistrar to registerpublic Set getPropertyEditorRegistrars()
public void registerCustomEditor(Class requiredType,
                                 Class propertyEditorClass)
ConfigurableBeanFactoryNote that this method will register a shared custom editor instance;
 access to that instance will be synchronized for thread-safety. It is
 generally preferable to use ConfigurableBeanFactory.addPropertyEditorRegistrar(org.springframework.beans.PropertyEditorRegistrar) instead
 of this method, to avoid for the need for synchronization on custom editors.
registerCustomEditor in interface ConfigurableBeanFactoryrequiredType - type of the propertypropertyEditorClass - the PropertyEditor class to register
public void registerCustomEditor(Class requiredType,
                                 PropertyEditor propertyEditor)
ConfigurableBeanFactoryNote that this method will register a shared custom editor instance;
 access to that instance will be synchronized for thread-safety. It is
 generally preferable to use ConfigurableBeanFactory.addPropertyEditorRegistrar(org.springframework.beans.PropertyEditorRegistrar) instead
 of this method, to avoid for the need for synchronization on custom editors.
registerCustomEditor in interface ConfigurableBeanFactoryrequiredType - type of the propertypropertyEditor - editor to registerpublic void copyRegisteredEditorsTo(PropertyEditorRegistry registry)
ConfigurableBeanFactory
copyRegisteredEditorsTo in interface ConfigurableBeanFactoryregistry - the PropertyEditorRegistry to initializepublic Map getCustomEditors()
public void setTypeConverter(TypeConverter typeConverter)
ConfigurableBeanFactoryThis will override the default PropertyEditor mechanism and hence make any custom editors or custom editor registrars irrelevant.
setTypeConverter in interface ConfigurableBeanFactoryConfigurableBeanFactory.addPropertyEditorRegistrar(org.springframework.beans.PropertyEditorRegistrar), 
ConfigurableBeanFactory.registerCustomEditor(java.lang.Class, java.lang.Class)protected TypeConverter getCustomTypeConverter()
null if none specifiedpublic TypeConverter getTypeConverter()
ConfigurableBeanFactoryIf the default PropertyEditor mechanism is active, the returned TypeConverter will be aware of all custom editors that have been registered.
getTypeConverter in interface ConfigurableBeanFactorypublic void addBeanPostProcessor(BeanPostProcessor beanPostProcessor)
ConfigurableBeanFactoryNote: Post-processors submitted here will be applied in the order of
 registration; any ordering semantics expressed through implementing the
 Ordered interface will be ignored. Note
 that autodetected post-processors (e.g. as beans in an ApplicationContext)
 will always be applied after programmatically registered ones.
addBeanPostProcessor in interface ConfigurableBeanFactorybeanPostProcessor - the post-processor to registerpublic int getBeanPostProcessorCount()
ConfigurableBeanFactory
getBeanPostProcessorCount in interface ConfigurableBeanFactorypublic List getBeanPostProcessors()
protected boolean hasInstantiationAwareBeanPostProcessors()
addBeanPostProcessor(org.springframework.beans.factory.config.BeanPostProcessor), 
InstantiationAwareBeanPostProcessorprotected boolean hasDestructionAwareBeanPostProcessors()
addBeanPostProcessor(org.springframework.beans.factory.config.BeanPostProcessor), 
DestructionAwareBeanPostProcessor
public void registerScope(String scopeName,
                          Scope scope)
ConfigurableBeanFactory
registerScope in interface ConfigurableBeanFactoryscopeName - the scope identifierscope - the backing Scope implementationpublic String[] getRegisteredScopeNames()
ConfigurableBeanFactoryThis will only return the names of explicitly registered scopes. Built-in scopes such as "singleton" and "prototype" won't be exposed.
getRegisteredScopeNames in interface ConfigurableBeanFactoryConfigurableBeanFactory.registerScope(java.lang.String, org.springframework.beans.factory.config.Scope)public Scope getRegisteredScope(String scopeName)
ConfigurableBeanFactoryThis will only return explicitly registered scopes. Built-in scopes such as "singleton" and "prototype" won't be exposed.
getRegisteredScope in interface ConfigurableBeanFactoryscopeName - the name of the scope
null if noneConfigurableBeanFactory.registerScope(java.lang.String, org.springframework.beans.factory.config.Scope)public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory)
ConfigurableBeanFactoryShould 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.
copyConfigurationFrom in interface ConfigurableBeanFactoryotherFactory - the other BeanFactory to copy from
public BeanDefinition getMergedBeanDefinition(String name)
                                       throws BeansException
This getMergedBeanDefinition considers bean definition
 in ancestors as well.
getMergedBeanDefinition in interface ConfigurableBeanFactoryname - the name of the bean to retrieve the merged definition for
 (may be an alias)
NoSuchBeanDefinitionException - if there is no bean with the given name
BeanDefinitionStoreException - in case of an invalid bean definition
BeansException
public boolean isFactoryBean(String name)
                      throws NoSuchBeanDefinitionException
ConfigurableBeanFactory
isFactoryBean in interface ConfigurableBeanFactoryname - the name of the bean to check
false means the bean exists but is not a FactoryBean)
NoSuchBeanDefinitionException - if there is no bean with the given nameprotected void beforePrototypeCreation(String beanName)
The default implementation register the prototype as currently in creation.
beanName - the name of the prototype about to be createdisPrototypeCurrentlyInCreation(java.lang.String)protected void afterPrototypeCreation(String beanName)
The default implementation marks the prototype as not in creation anymore.
beanName - the name of the prototype that has been createdisPrototypeCurrentlyInCreation(java.lang.String)protected final boolean isPrototypeCurrentlyInCreation(String beanName)
beanName - the name of the beanpublic boolean isCurrentlyInCreation(String beanName)
ConfigurableBeanFactory
isCurrentlyInCreation in interface ConfigurableBeanFactorybeanName - the name of the bean
public void destroyBean(String beanName,
                        Object beanInstance)
ConfigurableBeanFactoryAny exception that arises during destruction should be caught and logged instead of propagated to the caller of this method.
destroyBean in interface ConfigurableBeanFactorybeanName - the name of the bean definitionbeanInstance - the bean instance to destroy
protected void destroyBean(String beanName,
                           Object beanInstance,
                           RootBeanDefinition mbd)
beanName - the name of the bean definitionbeanInstance - the bean instance to destroymbd - the merged bean definitionpublic void destroyScopedBean(String beanName)
ConfigurableBeanFactoryAny exception that arises during destruction should be caught and logged instead of propagated to the caller of this method.
destroyScopedBean in interface ConfigurableBeanFactorybeanName - the name of the scoped beanprotected String transformedBeanName(String name)
name - the user-specified name
protected String originalBeanName(String name)
name - the user-specified name
protected void initBeanWrapper(BeanWrapper bw)
The default implementation delegates to registerCustomEditors(org.springframework.beans.PropertyEditorRegistry).
 Can be overridden in subclasses.
bw - the BeanWrapper to initializeprotected void registerCustomEditors(PropertyEditorRegistry registry)
To be called for BeanWrappers that will create and populate bean instances, and for SimpleTypeConverter used for constructor argument and factory method type conversion.
registry - the PropertyEditorRegistry to initialize
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName)
                                                   throws BeansException
beanName - the name of the bean to retrieve the merged definition for
NoSuchBeanDefinitionException - if there is no bean with the given name
BeanDefinitionStoreException - in case of an invalid bean definition
BeansException
protected RootBeanDefinition getMergedBeanDefinition(String beanName,
                                                     BeanDefinition bd)
                                              throws BeanDefinitionStoreException
beanName - the name of the bean definitionbd - the original bean definition (Root/ChildBeanDefinition)
BeanDefinitionStoreException - in case of an invalid bean definition
protected RootBeanDefinition getMergedBeanDefinition(String beanName,
                                                     BeanDefinition bd,
                                                     BeanDefinition containingBd)
                                              throws BeanDefinitionStoreException
beanName - the name of the bean definitionbd - the original bean definition (Root/ChildBeanDefinition)containingBd - the containing bean definition in case of inner bean,
 or null in case of a top-level bean
BeanDefinitionStoreException - in case of an invalid bean definition
protected void checkMergedBeanDefinition(RootBeanDefinition mbd,
                                         String beanName,
                                         Object[] args)
                                  throws BeanDefinitionStoreException
mbd - the merged bean definition to checkbeanName - the name of the beanargs - the arguments for bean creation, if any
BeanDefinitionStoreException - in case of validation failureprotected void clearMergedBeanDefinition(String beanName)
beanName - the bean name to clear the merged definition for
protected Class resolveBeanClass(RootBeanDefinition mbd,
                                 String beanName)
mbd - the merged bean definition to determine the class forbeanName - the name of the bean (for error handling purposes)
null if none)
CannotLoadBeanClassException - if we failed to load the class
protected Class resolveBeanClass(RootBeanDefinition mbd,
                                 String beanName,
                                 Class[] typesToMatch)
                          throws CannotLoadBeanClassException
mbd - the merged bean definition to determine the class forbeanName - the name of the bean (for error handling purposes)typesToMatch - the types to match in case of internal type matching purposes
 (also signals that the returned Class will never be exposed to application code)
null if none)
CannotLoadBeanClassException - if we failed to load the class
protected Class predictBeanType(String beanName,
                                RootBeanDefinition mbd,
                                Class[] typesToMatch)
getType(java.lang.String) and isTypeMatch(java.lang.String, java.lang.Class).
 Does not need to handle FactoryBeans specifically, since it is only
 supposed to operate on the raw bean type.
 This implementation is simplistic in that it is not able to handle factory methods and InstantiationAwareBeanPostProcessors. It only predicts the bean type correctly for a standard bean. To be overridden in subclasses, applying more sophisticated type detection.
beanName - the name of the beanmbd - the merged bean definition to determine the type fortypesToMatch - the types to match in case of internal type matching purposes
 (also signals that the returned Class will never be exposed to application code)
null if not predictable
protected boolean isFactoryBean(String beanName,
                                RootBeanDefinition mbd)
FactoryBean.
beanName - the name of the beanmbd - the corresponding bean definition
protected Class getTypeForFactoryBean(String beanName,
                                      RootBeanDefinition mbd)
The default implementation creates the FactoryBean via getBean
 to call its getObjectType method. Subclasses are encouraged to optimize
 this, typically by just instantiating the FactoryBean but not populating it yet,
 trying whether its getObjectType method already returns a type.
 If no type found, a full FactoryBean creation as performed by this implementation
 should be used as fallback.
beanName - the name of the beanmbd - the merged bean definition for the bean
null elseFactoryBean.getObjectType(), 
getBean(String)protected void markBeanAsCreated(String beanName)
This allows the bean factory to optimize its caching for repeated creation of the specified bean.
beanName - the name of the beanprotected boolean isBeanEligibleForMetadataCaching(String beanName)
beanName - the name of the bean
true if the bean's metadata may be cached
 at this point alreadyprotected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName)
beanName - the name of the bean
true if actually removed, false otherwise
protected Object getObjectForBeanInstance(Object beanInstance,
                                          String name,
                                          String beanName,
                                          RootBeanDefinition mbd)
beanInstance - the shared bean instancename - name that may include factory dereference prefixbeanName - the canonical bean namembd - the merged bean definition
public boolean isBeanNameInUse(String beanName)
beanName - the name to check
protected boolean requiresDestruction(Object bean,
                                      RootBeanDefinition mbd)
The default implementation checks the DisposableBean interface as well as a specified destroy method and registered DestructionAwareBeanPostProcessors.
bean - the bean instance to checkmbd - the corresponding bean definitionDisposableBean, 
AbstractBeanDefinition.getDestroyMethodName(), 
DestructionAwareBeanPostProcessor
protected void registerDisposableBeanIfNecessary(String beanName,
                                                 Object bean,
                                                 RootBeanDefinition mbd)
beanName - the name of the beanbean - the bean instancembd - the bean definition for the beanAbstractBeanDefinition.isSingleton(), 
AbstractBeanDefinition.getDependsOn(), 
DefaultSingletonBeanRegistry.registerDisposableBean(java.lang.String, org.springframework.beans.factory.DisposableBean), 
DefaultSingletonBeanRegistry.registerDependentBean(java.lang.String, java.lang.String)protected abstract boolean containsBeanDefinition(String beanName)
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.
beanName - the name of the bean to look for
containsBean(java.lang.String), 
ListableBeanFactory.containsBeanDefinition(java.lang.String)
protected abstract BeanDefinition getBeanDefinition(String beanName)
                                             throws BeansException
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.
beanName - the name of the bean to find a definition for
null)
NoSuchBeanDefinitionException - if the bean definition cannot be resolved
BeansException - in case of errorsRootBeanDefinition, 
ChildBeanDefinition, 
ConfigurableListableBeanFactory.getBeanDefinition(java.lang.String)
protected abstract Object createBean(String beanName,
                                     RootBeanDefinition mbd,
                                     Object[] args)
                              throws BeanCreationException
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.
beanName - the name of the beanmbd - the merged bean definition for the beanargs - arguments to use if creating a prototype using explicit arguments to a
 static factory method. This parameter must be null except in this case.
BeanCreationException - if the bean could not be created| 
 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||