org.springframework.context.support

## Class AbstractRefreshableApplicationContext

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

- All Implemented Interfaces:
    Closeable, AutoCloseable, BeanFactory, HierarchicalBeanFactory, ListableBeanFactory, ApplicationContext, ApplicationEventPublisher, ConfigurableApplicationContext, Lifecycle, MessageSource, EnvironmentCapable, ResourceLoader, ResourcePatternResolver
  Direct Known Subclasses:
    AbstractRefreshableConfigApplicationContext

      public abstract class AbstractRefreshableApplicationContext
      extends AbstractApplicationContext

  Base class for `ApplicationContext` implementations which are supposed to support multiple calls to `AbstractApplicationContext.refresh()`, creating a new internal bean factory instance every time. Typically (but not necessarily), such a context will be driven by a set of config locations to load bean definitions from.

  The only method to be implemented by subclasses is `loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)`, which gets invoked on each refresh. A concrete implementation is supposed to load bean definitions into the given `DefaultListableBeanFactory`, typically delegating to one or more specific bean definition readers.

  Note that there is a similar base class for WebApplicationContexts. `AbstractRefreshableWebApplicationContext` provides the same subclassing strategy, but additionally pre-implements all context functionality for web environments. There is also a pre-defined way to receive config locations for a web context.

  Concrete standalone subclasses of this base class, reading in a specific bean definition format, are `ClassPathXmlApplicationContext` and `FileSystemXmlApplicationContext`, which both derive from the common `AbstractXmlApplicationContext` base class; `AnnotationConfigApplicationContext` supports `@Configuration`-annotated classes as a source of bean definitions.

  Since:
    1.1.3
  Author:
    Juergen Hoeller, Chris Beams
  See Also:
    `loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)`, `DefaultListableBeanFactory`, `AbstractRefreshableWebApplicationContext`, `AbstractXmlApplicationContext`, `ClassPathXmlApplicationContext`, `FileSystemXmlApplicationContext`, `AnnotationConfigApplicationContext`

- - ### 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.context.ConfigurableApplicationContext

      `APPLICATION_STARTUP_BEAN_NAME, CONFIG_LOCATION_DELIMITERS, CONVERSION_SERVICE_BEAN_NAME, ENVIRONMENT_BEAN_NAME, LOAD_TIME_WEAVER_BEAN_NAME, SHUTDOWN_HOOK_THREAD_NAME, SYSTEM_ENVIRONMENT_BEAN_NAME, SYSTEM_PROPERTIES_BEAN_NAME`

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

    Constructors
    Constructor and Description
    `AbstractRefreshableApplicationContext()` Create a new AbstractRefreshableApplicationContext with no parent.
    `AbstractRefreshableApplicationContext(ApplicationContext parent)` Create a new AbstractRefreshableApplicationContext with the given parent context.

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `assertBeanFactoryActive()` Overridden to turn it into a no-op: With AbstractRefreshableApplicationContext, `getBeanFactory()` serves a strong assertion for an active context anyway.
    `protected void` | `cancelRefresh(BeansException ex)` Cancel this context's refresh attempt, resetting the `active` flag after an exception got thrown.
    `protected void` | `closeBeanFactory()` Subclasses must implement this method to release their internal bean factory.
    `protected DefaultListableBeanFactory` | `createBeanFactory()` Create an internal bean factory for this context.
    `protected void` | `customizeBeanFactory(DefaultListableBeanFactory beanFactory)` Customize the internal bean factory used by this context.
    `ConfigurableListableBeanFactory` | `getBeanFactory()` Subclasses must return their internal bean factory here.
    `protected boolean` | `hasBeanFactory()` Determine whether this context currently holds a bean factory, i.e.
    `protected abstract void` | `loadBeanDefinitions(DefaultListableBeanFactory beanFactory)` Load bean definitions into the given bean factory, typically through delegating to one or more bean definition readers.
    `protected void` | `refreshBeanFactory()` This implementation performs an actual refresh of this context's underlying bean factory, shutting down the previous bean factory (if any) and initializing a fresh bean factory for the next phase of the context's lifecycle.
    `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.

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

      `addApplicationListener, addBeanFactoryPostProcessor, close, containsBean, containsBeanDefinition, containsLocalBean, createEnvironment, destroy, destroyBeans, doClose, findAnnotationOnBean, findAnnotationOnBean, finishBeanFactoryInitialization, finishRefresh, getAliases, getApplicationListeners, getApplicationName, getApplicationStartup, getAutowireCapableBeanFactory, getBean, getBean, getBean, getBean, getBean, getBeanDefinitionCount, getBeanDefinitionNames, getBeanFactoryPostProcessors, getBeanNamesForAnnotation, getBeanNamesForType, getBeanNamesForType, getBeanNamesForType, getBeanNamesForType, getBeanProvider, getBeanProvider, getBeanProvider, getBeanProvider, getBeansOfType, getBeansOfType, getBeansWithAnnotation, getDisplayName, getEnvironment, getId, getInternalParentBeanFactory, getInternalParentMessageSource, getMessage, getMessage, getMessage, getParent, getParentBeanFactory, getResourcePatternResolver, getResources, getStartupDate, getType, 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, setApplicationStartup, setDisplayName, setEnvironment, setId, setParent, start, stop, toString`

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

      `addProtocolResolver, clearResourceCaches, getClassLoader, getProtocolResolvers, getResource, getResourceByPath, getResourceCache, setClassLoader`

    - ### Methods inherited from class java.lang.Object

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

    - ### Methods inherited from interface org.springframework.context.ConfigurableApplicationContext

      `addProtocolResolver, setClassLoader`

    - ### Methods inherited from interface org.springframework.core.io.ResourceLoader

      `getClassLoader, getResource`

- - ### Constructor Detail

    - #### AbstractRefreshableApplicationContext

          public AbstractRefreshableApplicationContext()

      Create a new AbstractRefreshableApplicationContext with no parent.

    - #### AbstractRefreshableApplicationContext

          public AbstractRefreshableApplicationContext(@Nullable
                                                       ApplicationContext parent)

      Create a new AbstractRefreshableApplicationContext with the given parent context.
      Parameters:
        `parent` - the parent context

  - ### Method Detail

    - #### 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".
      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.

      See Also:
        `AbstractAutowireCapableBeanFactory.setAllowCircularReferences(boolean)`

    - #### refreshBeanFactory

          protected final void refreshBeanFactory()
                                           throws BeansException

      This implementation performs an actual refresh of this context's underlying bean factory, shutting down the previous bean factory (if any) and initializing a fresh bean factory for the next phase of the context's lifecycle.
      Specified by:
        `refreshBeanFactory` in class `AbstractApplicationContext`
      Throws:
        `BeansException` - if initialization of the bean factory failed

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

      Description copied from class: `AbstractApplicationContext`
      Subclasses must implement this method to release their internal bean factory. This method gets invoked by `AbstractApplicationContext.close()` after all other shutdown work.

      Should never throw an exception but rather log shutdown failures.

      Specified by:
        `closeBeanFactory` in class `AbstractApplicationContext`

    - #### hasBeanFactory

          protected final boolean hasBeanFactory()

      Determine whether this context currently holds a bean factory, i.e. has been refreshed at least once and not been closed yet.

    - #### getBeanFactory

          public final ConfigurableListableBeanFactory getBeanFactory()

      Description copied from class: `AbstractApplicationContext`
      Subclasses must return their internal bean factory here. They should implement the lookup efficiently, so that it can be called repeatedly without a performance penalty.

      Note: Subclasses should check whether the context is still active before returning the internal bean factory. The internal factory should generally be considered unavailable once the context has been closed.

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

    - #### assertBeanFactoryActive

          protected void assertBeanFactoryActive()

      Overridden to turn it into a no-op: With AbstractRefreshableApplicationContext, `getBeanFactory()` serves a strong assertion for an active context anyway.
      Overrides:
        `assertBeanFactoryActive` in class `AbstractApplicationContext`

    - #### createBeanFactory

          protected DefaultListableBeanFactory createBeanFactory()

      Create an internal bean factory for this context. Called for each `AbstractApplicationContext.refresh()` attempt.

      The default implementation creates a `DefaultListableBeanFactory` with the internal bean factory of this context's parent as parent bean factory. Can be overridden in subclasses, for example to customize DefaultListableBeanFactory's settings.

      Returns:
        the bean factory for this context
      See Also:
        `DefaultListableBeanFactory.setAllowBeanDefinitionOverriding(boolean)`, `DefaultListableBeanFactory.setAllowEagerClassLoading(boolean)`, `AbstractAutowireCapableBeanFactory.setAllowCircularReferences(boolean)`, `AbstractAutowireCapableBeanFactory.setAllowRawInjectionDespiteWrapping(boolean)`

    - #### customizeBeanFactory

          protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory)

      Customize the internal bean factory used by this context. Called for each `AbstractApplicationContext.refresh()` attempt.

      The default implementation applies this context's "allowBeanDefinitionOverriding" and "allowCircularReferences" settings, if specified. Can be overridden in subclasses to customize any of `DefaultListableBeanFactory`'s settings.

      Parameters:
        `beanFactory` - the newly created bean factory for this context
      See Also:
        `DefaultListableBeanFactory.setAllowBeanDefinitionOverriding(boolean)`, `AbstractAutowireCapableBeanFactory.setAllowCircularReferences(boolean)`, `AbstractAutowireCapableBeanFactory.setAllowRawInjectionDespiteWrapping(boolean)`, `DefaultListableBeanFactory.setAllowEagerClassLoading(boolean)`

    - #### loadBeanDefinitions

          protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
                                               throws BeansException,
                                                      IOException

      Load bean definitions into the given bean factory, typically through delegating to one or more bean definition readers.
      Parameters:
        `beanFactory` - the bean factory to load bean definitions into
      Throws:
        `BeansException` - if parsing of the bean definitions failed
        `IOException` - if loading of bean definition files failed
      See Also:
        `PropertiesBeanDefinitionReader`, `XmlBeanDefinitionReader`