java.lang.Object
- org.springframework.core.io.DefaultResourceLoader
- - org.springframework.context.support.AbstractApplicationContext
  - - org.springframework.context.support.GenericApplicationContext

All Implemented Interfaces:
Closeable, AutoCloseable, BeanFactory, DisposableBean, HierarchicalBeanFactory, ListableBeanFactory, BeanDefinitionRegistry, ApplicationContext, ApplicationEventPublisher, ConfigurableApplicationContext, Lifecycle, MessageSource, AliasRegistry, EnvironmentCapable, ResourceLoader, ResourcePatternResolver
Direct Known Subclasses:
AnnotationConfigApplicationContext, GenericGroovyApplicationContext, GenericWebApplicationContext, GenericXmlApplicationContext, ResourceAdapterApplicationContext, StaticApplicationContext
```
public class GenericApplicationContext
extends AbstractApplicationContext
implements BeanDefinitionRegistry
```
Generic ApplicationContext implementation that holds a single internal DefaultListableBeanFactory instance and does not assume a specific bean definition format. Implements the BeanDefinitionRegistry interface in order to allow for applying any bean definition readers to it.
Typical usage is to register a variety of bean definitions via the BeanDefinitionRegistry interface and then call AbstractApplicationContext.refresh() to initialize those beans with application context semantics (handling ApplicationContextAware, auto-detecting BeanFactoryPostProcessors, etc).
In contrast to other ApplicationContext implementations that create a new internal BeanFactory instance for each refresh, the internal BeanFactory of this context is available right from the start, to be able to register bean definitions on it. AbstractApplicationContext.refresh() may only be called once.
Usage example:
```
 GenericApplicationContext ctx = new GenericApplicationContext();
 XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(ctx);
 xmlReader.loadBeanDefinitions(new ClassPathResource("applicationContext.xml"));
 PropertiesBeanDefinitionReader propReader = new PropertiesBeanDefinitionReader(ctx);
 propReader.loadBeanDefinitions(new ClassPathResource("otherBeans.properties"));
 ctx.refresh();

 MyBean myBean = (MyBean) ctx.getBean("myBean");
 ...
```
For the typical case of XML bean definitions, simply use ClassPathXmlApplicationContext or FileSystemXmlApplicationContext, which are easier to set up - but less flexible, since you can just use standard resource locations for XML bean definitions, rather than mixing arbitrary bean definition formats. The equivalent in a web environment is XmlWebApplicationContext.
For custom application context implementations that are supposed to read special bean definition formats in a refreshable manner, consider deriving from the AbstractRefreshableApplicationContext base class.
Since:
1.1.2
Author:
Juergen Hoeller, Chris Beams
See Also:
registerBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition), AbstractApplicationContext.refresh(), XmlBeanDefinitionReader, PropertiesBeanDefinitionReader

Nested Class Summary
- Nested classes/interfaces inherited from class org.springframework.core.io.DefaultResourceLoader
  DefaultResourceLoader.ClassPathContextResource

Field Summary
- Fields inherited from class org.springframework.context.support.AbstractApplicationContext
  APPLICATION_EVENT_MULTICASTER_BEAN_NAME, LIFECYCLE_PROCESSOR_BEAN_NAME, logger, MESSAGE_SOURCE_BEAN_NAME
- Fields inherited from interface org.springframework.beans.factory.BeanFactory
  FACTORY_BEAN_PREFIX
- Fields inherited from interface org.springframework.context.ConfigurableApplicationContext
  CONFIG_LOCATION_DELIMITERS, CONVERSION_SERVICE_BEAN_NAME, ENVIRONMENT_BEAN_NAME, LOAD_TIME_WEAVER_BEAN_NAME, SYSTEM_ENVIRONMENT_BEAN_NAME, SYSTEM_PROPERTIES_BEAN_NAME
- Fields inherited from interface org.springframework.core.io.ResourceLoader
  CLASSPATH_URL_PREFIX
- Fields inherited from interface org.springframework.core.io.support.ResourcePatternResolver
  CLASSPATH_ALL_URL_PREFIX

Constructor Summary

Constructors
Constructor	Description
`GenericApplicationContext()`	Create a new GenericApplicationContext.
`GenericApplicationContext(DefaultListableBeanFactory beanFactory)`	Create a new GenericApplicationContext with the given DefaultListableBeanFactory.
`GenericApplicationContext(DefaultListableBeanFactory beanFactory, ApplicationContext parent)`	Create a new GenericApplicationContext with the given DefaultListableBeanFactory.
`GenericApplicationContext(ApplicationContext parent)`	Create a new GenericApplicationContext with the given parent.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected void`	`cancelRefresh(BeansException ex)`	Cancel this context's refresh attempt, resetting the `active` flag after an exception got thrown.
`protected void`	`closeBeanFactory()`	Not much to do: We hold a single internal BeanFactory that will never get released.
`AutowireCapableBeanFactory`	`getAutowireCapableBeanFactory()`	Return this context's internal bean factory as AutowireCapableBeanFactory, if already available.
`BeanDefinition`	`getBeanDefinition(String beanName)`	Return the BeanDefinition for the given bean name.
`ConfigurableListableBeanFactory`	`getBeanFactory()`	Return the single internal BeanFactory held by this context (as ConfigurableListableBeanFactory).
`ClassLoader`	`getClassLoader()`	Return the ClassLoader to load class path resources with.
`DefaultListableBeanFactory`	`getDefaultListableBeanFactory()`	Return the underlying bean factory of this context, available for registering bean definitions.
`Resource`	`getResource(String location)`	This implementation delegates to this context's ResourceLoader if set, falling back to the default superclass behavior else.
`Resource[]`	`getResources(String locationPattern)`	This implementation delegates to this context's ResourceLoader if it implements the ResourcePatternResolver interface, falling back to the default superclass behavior else.
`boolean`	`isAlias(String beanName)`	Determine whether this given name is defines as an alias (as opposed to the name of an actually registered component).
`boolean`	`isBeanNameInUse(String beanName)`	Determine whether the given bean name is already in use within this registry, i.e.
`protected void`	`refreshBeanFactory()`	Do nothing: We hold a single internal BeanFactory and rely on callers to register beans through our public methods (or the BeanFactory's).
`void`	`registerAlias(String beanName, String alias)`	Given a name, register an alias for it.
`void`	`registerBeanDefinition(String beanName, BeanDefinition beanDefinition)`	Register a new bean definition with this registry.
`void`	`removeAlias(String alias)`	Remove the specified alias from this registry.
`void`	`removeBeanDefinition(String beanName)`	Remove the BeanDefinition for the given name.
`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`	`setAllowCircularReferences(boolean allowCircularReferences)`	Set whether to allow circular references between beans - and automatically try to resolve them.
`void`	`setClassLoader(ClassLoader classLoader)`	Specify the ClassLoader to load class path resources with, or `null` for using the thread context class loader at the time of actual resource access.
`void`	`setParent(ApplicationContext parent)`	Set the parent of this application context, also setting the parent of the internal BeanFactory accordingly.
`void`	`setResourceLoader(ResourceLoader resourceLoader)`	Set a ResourceLoader to use for this context.

Methods inherited from class org.springframework.context.support.AbstractApplicationContext
addApplicationListener, addBeanFactoryPostProcessor, assertBeanFactoryActive, close, containsBean, containsBeanDefinition, containsLocalBean, createEnvironment, destroy, destroyBeans, doClose, findAnnotationOnBean, finishBeanFactoryInitialization, finishRefresh, getAliases, getApplicationListeners, getApplicationName, getBean, getBean, getBean, getBean, getBean, getBeanDefinitionCount, getBeanDefinitionNames, getBeanFactoryPostProcessors, getBeanNamesForAnnotation, getBeanNamesForType, getBeanNamesForType, getBeanNamesForType, getBeansOfType, getBeansOfType, getBeansWithAnnotation, getDisplayName, getEnvironment, getId, getInternalParentBeanFactory, getInternalParentMessageSource, getMessage, getMessage, getMessage, getParent, getParentBeanFactory, getResourcePatternResolver, getStartupDate, getType, initApplicationEventMulticaster, initLifecycleProcessor, initMessageSource, initPropertySources, invokeBeanFactoryPostProcessors, isActive, isPrototype, isRunning, isSingleton, isTypeMatch, isTypeMatch, obtainFreshBeanFactory, onClose, onRefresh, postProcessBeanFactory, prepareBeanFactory, prepareRefresh, publishEvent, publishEvent, publishEvent, refresh, registerBeanPostProcessors, registerListeners, registerShutdownHook, resetCommonCaches, setDisplayName, setEnvironment, setId, start, stop, toString

Methods inherited from class org.springframework.core.io.DefaultResourceLoader
addProtocolResolver, getProtocolResolvers, getResourceByPath

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

Methods inherited from interface org.springframework.core.AliasRegistry
getAliases

Methods inherited from interface org.springframework.beans.factory.support.BeanDefinitionRegistry
containsBeanDefinition, getBeanDefinitionCount, getBeanDefinitionNames

Methods inherited from interface org.springframework.context.ConfigurableApplicationContext
addProtocolResolver

- Constructor Detail
  - GenericApplicationContext
```
public GenericApplicationContext()
```
    Create a new GenericApplicationContext.
    See Also:
    registerBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition), AbstractApplicationContext.refresh()
  - GenericApplicationContext
```
public GenericApplicationContext(DefaultListableBeanFactory beanFactory)
```
    Create a new GenericApplicationContext with the given DefaultListableBeanFactory.
    Parameters:
    beanFactory - the DefaultListableBeanFactory instance to use for this context
    See Also:
    registerBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition), AbstractApplicationContext.refresh()
  - GenericApplicationContext
```
public GenericApplicationContext(ApplicationContext parent)
```
    Create a new GenericApplicationContext with the given parent.
    Parameters:
    parent - the parent application context
    See Also:
    registerBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition), AbstractApplicationContext.refresh()
  - GenericApplicationContext
```
public GenericApplicationContext(DefaultListableBeanFactory beanFactory,
                                 ApplicationContext parent)
```
    Create a new GenericApplicationContext with the given DefaultListableBeanFactory.
    Parameters:
    beanFactory - the DefaultListableBeanFactory instance to use for this context
    parent - the parent application context
    See Also:
    registerBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition), AbstractApplicationContext.refresh()
- Method Detail
  - setParent
```
public void setParent(ApplicationContext parent)
```
    Set the parent of this application context, also setting the parent of the internal BeanFactory accordingly.
    Specified by:
    setParent in interface ConfigurableApplicationContext
    Overrides:
    setParent in class AbstractApplicationContext
    Parameters:
    parent - the parent context
    See Also:
    ConfigurableBeanFactory.setParentBeanFactory(org.springframework.beans.factory.BeanFactory)
  - setAllowBeanDefinitionOverriding
```
public 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. If not, an exception will be thrown. Default is "true".
    Since:
    3.0
    See Also:
    DefaultListableBeanFactory.setAllowBeanDefinitionOverriding(boolean)
  - setAllowCircularReferences
```
public void setAllowCircularReferences(boolean allowCircularReferences)
```
    Set whether to allow circular references between beans - and automatically try to resolve them.
    Default is "true". Turn this off to throw an exception when encountering a circular reference, disallowing them completely.
    Since:
    3.0
    See Also:
    AbstractAutowireCapableBeanFactory.setAllowCircularReferences(boolean)
  - setResourceLoader
```
public void setResourceLoader(ResourceLoader resourceLoader)
```
    Set a ResourceLoader to use for this context. If set, the context will delegate all getResource calls to the given ResourceLoader. If not set, default resource loading will apply.
    The main reason to specify a custom ResourceLoader is to resolve resource paths (without URL prefix) in a specific fashion. The default behavior is to resolve such paths as class path locations. To resolve resource paths as file system locations, specify a FileSystemResourceLoader here.
    You can also pass in a full ResourcePatternResolver, which will be autodetected by the context and used for getResources calls as well. Else, default resource pattern matching will apply.
    See Also:
    getResource(java.lang.String), DefaultResourceLoader, FileSystemResourceLoader, ResourcePatternResolver, getResources(java.lang.String)
  - getResource
```
public Resource getResource(String location)
```
    This implementation delegates to this context's ResourceLoader if set, falling back to the default superclass behavior else.
    Specified by:
    getResource in interface ResourceLoader
    Overrides:
    getResource in class DefaultResourceLoader
    Parameters:
    location - the resource location
    Returns:
    a corresponding Resource handle (never null)
    See Also:
    setResourceLoader(org.springframework.core.io.ResourceLoader)
  - getResources
```
public Resource[] getResources(String locationPattern)
                        throws IOException
```
    This implementation delegates to this context's ResourceLoader if it implements the ResourcePatternResolver interface, falling back to the default superclass behavior else.
    Specified by:
    getResources in interface ResourcePatternResolver
    Overrides:
    getResources in class AbstractApplicationContext
    Parameters:
    locationPattern - the location pattern to resolve
    Returns:
    the corresponding Resource objects
    Throws:
    IOException - in case of I/O errors
    See Also:
    setResourceLoader(org.springframework.core.io.ResourceLoader)
  - setClassLoader
```
public void setClassLoader(ClassLoader classLoader)
```
    Description copied from class: DefaultResourceLoader
    Specify the ClassLoader to load class path resources with, or null for using the thread context class loader at the time of actual resource access.
    The default is that ClassLoader access will happen using the thread context class loader at the time of this ResourceLoader's initialization.
    Overrides:
    setClassLoader in class DefaultResourceLoader
  - getClassLoader
```
public ClassLoader getClassLoader()
```
    Description copied from class: DefaultResourceLoader
    Return the ClassLoader to load class path resources with.
    Will get passed to ClassPathResource's constructor for all ClassPathResource objects created by this resource loader.
    Specified by:
    getClassLoader in interface ResourceLoader
    Overrides:
    getClassLoader in class DefaultResourceLoader
    Returns:
    the ClassLoader (only null if even the system ClassLoader isn't accessible)
    See Also:
    ClassPathResource
  - refreshBeanFactory
```
protected final void refreshBeanFactory()
                                 throws IllegalStateException
```
    Do nothing: We hold a single internal BeanFactory and rely on callers to register beans through our public methods (or the BeanFactory's).
    Specified by:
    refreshBeanFactory in class AbstractApplicationContext
    Throws:
    IllegalStateException - if already initialized and multiple refresh attempts are not supported
    See Also:
    registerBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition)
  - cancelRefresh
```
protected void cancelRefresh(BeansException ex)
```
    Description copied from class: AbstractApplicationContext
    Cancel this context's refresh attempt, resetting the active flag after an exception got thrown.
    Overrides:
    cancelRefresh in class AbstractApplicationContext
    Parameters:
    ex - the exception that led to the cancellation
  - closeBeanFactory
```
protected final void closeBeanFactory()
```
    Not much to do: We hold a single internal BeanFactory that will never get released.
    Specified by:
    closeBeanFactory in class AbstractApplicationContext
  - getBeanFactory
```
public final ConfigurableListableBeanFactory getBeanFactory()
```
    Return the single internal BeanFactory held by this context (as ConfigurableListableBeanFactory).
    Specified by:
    getBeanFactory in interface ConfigurableApplicationContext
    Specified by:
    getBeanFactory in class AbstractApplicationContext
    Returns:
    this application context's internal bean factory (never null)
    See Also:
    AbstractApplicationContext.refreshBeanFactory(), AbstractApplicationContext.closeBeanFactory()
  - getDefaultListableBeanFactory
```
public final DefaultListableBeanFactory getDefaultListableBeanFactory()
```
    Return the underlying bean factory of this context, available for registering bean definitions.
    NOTE: You need to call AbstractApplicationContext.refresh() to initialize the bean factory and its contained beans with application context semantics (autodetecting BeanFactoryPostProcessors, etc).
    Returns:
    the internal bean factory (as DefaultListableBeanFactory)
  - getAutowireCapableBeanFactory
```
public AutowireCapableBeanFactory getAutowireCapableBeanFactory()
                                                         throws IllegalStateException
```
    Description copied from class: AbstractApplicationContext
    Return this context's internal bean factory as AutowireCapableBeanFactory, if already available.
    Specified by:
    getAutowireCapableBeanFactory in interface ApplicationContext
    Overrides:
    getAutowireCapableBeanFactory in class AbstractApplicationContext
    Returns:
    the AutowireCapableBeanFactory for this context
    Throws:
    IllegalStateException - if the context does not support the AutowireCapableBeanFactory interface, or does not hold an autowire-capable bean factory yet (e.g. if refresh() has never been called), or if the context has been closed already
    See Also:
    AbstractApplicationContext.getBeanFactory()
  - registerBeanDefinition
```
public void registerBeanDefinition(String beanName,
                                   BeanDefinition beanDefinition)
                            throws BeanDefinitionStoreException
```
    Description copied from interface: BeanDefinitionRegistry
    Register a new bean definition with this registry. Must support RootBeanDefinition and ChildBeanDefinition.
    Specified by:
    registerBeanDefinition in interface BeanDefinitionRegistry
    Parameters:
    beanName - the name of the bean instance to register
    beanDefinition - definition of the bean instance to register
    Throws:
    BeanDefinitionStoreException - if the BeanDefinition is invalid or if there is already a BeanDefinition for the specified bean name (and we are not allowed to override it)
    See Also:
    GenericBeanDefinition, RootBeanDefinition, ChildBeanDefinition
  - removeBeanDefinition
```
public void removeBeanDefinition(String beanName)
                          throws NoSuchBeanDefinitionException
```
    Description copied from interface: BeanDefinitionRegistry
    Remove the BeanDefinition for the given name.
    Specified by:
    removeBeanDefinition in interface BeanDefinitionRegistry
    Parameters:
    beanName - the name of the bean instance to register
    Throws:
    NoSuchBeanDefinitionException - if there is no such bean definition
  - getBeanDefinition
```
public BeanDefinition getBeanDefinition(String beanName)
                                 throws NoSuchBeanDefinitionException
```
    Description copied from interface: BeanDefinitionRegistry
    Return the BeanDefinition for the given bean name.
    Specified by:
    getBeanDefinition in interface BeanDefinitionRegistry
    Parameters:
    beanName - name of the bean to find a definition for
    Returns:
    the BeanDefinition for the given name (never null)
    Throws:
    NoSuchBeanDefinitionException - if there is no such bean definition
  - isBeanNameInUse
```
public boolean isBeanNameInUse(String beanName)
```
    Description copied from interface: BeanDefinitionRegistry
    Determine whether the given bean name is already in use within this registry, i.e. whether there is a local bean or alias registered under this name.
    Specified by:
    isBeanNameInUse in interface BeanDefinitionRegistry
    Parameters:
    beanName - the name to check
    Returns:
    whether the given bean name is already in use
  - registerAlias
```
public void registerAlias(String beanName,
                          String alias)
```
    Description copied from interface: AliasRegistry
    Given a name, register an alias for it.
    Specified by:
    registerAlias in interface AliasRegistry
    Parameters:
    beanName - the canonical name
    alias - the alias to be registered
  - removeAlias
```
public void removeAlias(String alias)
```
    Description copied from interface: AliasRegistry
    Remove the specified alias from this registry.
    Specified by:
    removeAlias in interface AliasRegistry
    Parameters:
    alias - the alias to remove
  - isAlias
```
public boolean isAlias(String beanName)
```
    Description copied from interface: AliasRegistry
    Determine whether this given name is defines as an alias (as opposed to the name of an actually registered component).
    Specified by:
    isAlias in interface AliasRegistry
    Parameters:
    beanName - the name to check
    Returns:
    whether the given name is an alias

Class GenericApplicationContext

Nested Class Summary

Nested classes/interfaces inherited from class org.springframework.core.io.DefaultResourceLoader

Field Summary

Fields inherited from class org.springframework.context.support.AbstractApplicationContext

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

Fields inherited from interface org.springframework.context.ConfigurableApplicationContext

Fields inherited from interface org.springframework.core.io.ResourceLoader

Fields inherited from interface org.springframework.core.io.support.ResourcePatternResolver

Constructor Summary

Method Summary

Methods inherited from class org.springframework.context.support.AbstractApplicationContext

Methods inherited from class org.springframework.core.io.DefaultResourceLoader

Methods inherited from class java.lang.Object

Methods inherited from interface org.springframework.core.AliasRegistry

Methods inherited from interface org.springframework.beans.factory.support.BeanDefinitionRegistry

Methods inherited from interface org.springframework.context.ConfigurableApplicationContext

Constructor Detail

GenericApplicationContext

GenericApplicationContext

GenericApplicationContext

GenericApplicationContext

Method Detail

setParent

setAllowBeanDefinitionOverriding

setAllowCircularReferences

setResourceLoader

getResource

getResources

setClassLoader

getClassLoader

refreshBeanFactory

cancelRefresh

closeBeanFactory

getBeanFactory

getDefaultListableBeanFactory

getAutowireCapableBeanFactory

registerBeanDefinition

removeBeanDefinition

getBeanDefinition

isBeanNameInUse

registerAlias

removeAlias

isAlias