Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.context.support
Class GenericApplicationContext

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

All Implemented Interfaces:
  BeanFactory, DisposableBean, HierarchicalBeanFactory, ListableBeanFactory, BeanDefinitionRegistry, ApplicationContext, ApplicationEventPublisher, ConfigurableApplicationContext, Lifecycle, MessageSource, ResourceLoader, ResourcePatternResolver

Direct Known Subclasses:
  GenericWebApplicationContext, 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
See Also:
  `registerBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition)`, `AbstractApplicationContext.refresh()`, `XmlBeanDefinitionReader`, `PropertiesBeanDefinitionReader`

Field Summary

Fields inherited from class org.springframework.context.support.AbstractApplicationContext
`APPLICATION_EVENT_MULTICASTER_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.beans.factory.BeanFactory
`FACTORY_BEAN_PREFIX`

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

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

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

Method Summary
`protected void` | `closeBeanFactory()` Do nothing: We hold a single internal BeanFactory that will never get released.
`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).
`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.
`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 bean name, create an alias.
`void` | `registerBeanDefinition(String beanName, BeanDefinition beanDefinition)` Register a new bean definition with this registry.
`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, addListener, cancelRefresh, close, containsBean, containsBeanDefinition, containsLocalBean, destroy, destroyBeans, doClose, finishRefresh, getAliases, getApplicationListeners, getAutowireCapableBeanFactory, getBean, getBean, getBeanDefinitionCount, getBeanDefinitionNames, getBeanFactoryPostProcessors, getBeanNamesForType, getBeanNamesForType, getBeansOfType, getBeansOfType, getDisplayName, getInternalParentBeanFactory, getInternalParentMessageSource, getLifecycleBeans, getMessage, getMessage, getMessage, getParent, getParentBeanFactory, getResourcePatternResolver, getStartupDate, getType, initApplicationEventMulticaster, initMessageSource, invokeBeanFactoryPostProcessors, isActive, isPrototype, isRunning, isSingleton, isTypeMatch, obtainFreshBeanFactory, onClose, onRefresh, postProcessBeanFactory, prepareBeanFactory, prepareRefresh, publishEvent, refresh, registerBeanPostProcessors, registerListeners, registerShutdownHook, setDisplayName, start, stop, toString`

Methods inherited from class org.springframework.core.io.DefaultResourceLoader
`getClassLoader, getResourceByPath, setClassLoader`

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

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

Methods inherited from interface org.springframework.core.io.ResourceLoader
`getClassLoader`

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)`

### 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 (withour 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
  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)`

### 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)`

### closeBeanFactory

    protected final void closeBeanFactory()

  Do nothing: 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)

### getBeanDefinition

    public BeanDefinition getBeanDefinition(String beanName)
                                     throws BeansException

  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
    `BeansException`

### registerBeanDefinition

    public void registerBeanDefinition(String beanName,
                                       BeanDefinition beanDefinition)
                                throws BeansException

  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)
    `BeansException`
  See Also:
    `RootBeanDefinition`, `ChildBeanDefinition`

### registerAlias

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

  Description copied from interface: `BeanDefinitionRegistry`
  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).

  Specified by:
    `registerAlias` in interface `BeanDefinitionRegistry`
  Parameters:
    `beanName` - the canonical name of the bean
    `alias` - the alias to be registered for the bean
  Throws:
    `BeanDefinitionStoreException` - if the alias is already in use
    `BeansException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002-2007 The Spring Framework.