Package org.springframework.context.support

# Class AbstractApplicationContext

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

All Implemented Interfaces:
  `Closeable`, `AutoCloseable`, `org.springframework.beans.factory.BeanFactory`, `org.springframework.beans.factory.HierarchicalBeanFactory`, `org.springframework.beans.factory.ListableBeanFactory`, `ApplicationContext`, `ApplicationEventPublisher`, `ConfigurableApplicationContext`, `Lifecycle`, `MessageSource`, `org.springframework.core.env.EnvironmentCapable`, `org.springframework.core.io.ResourceLoader`, `org.springframework.core.io.support.ResourcePatternResolver`

Direct Known Subclasses:
  `AbstractRefreshableApplicationContext`, `GenericApplicationContext`

public abstract class AbstractApplicationContext extends org.springframework.core.io.DefaultResourceLoader implements ConfigurableApplicationContext
Abstract implementation of the `ApplicationContext` interface. Doesn't mandate the type of storage used for configuration; simply implements common context functionality. Uses the Template Method design pattern, requiring concrete subclasses to implement abstract methods.

In contrast to a plain BeanFactory, an ApplicationContext is supposed to detect special beans defined in its internal bean factory: Therefore, this class automatically registers `BeanFactoryPostProcessors`, `BeanPostProcessors`, and `ApplicationListeners` which are defined as beans in the context.

A `MessageSource` may also be supplied as a bean in the context, with the name "messageSource"; otherwise, message resolution is delegated to the parent context. Furthermore, a multicaster for application events can be supplied as an "applicationEventMulticaster" bean of type `ApplicationEventMulticaster` in the context; otherwise, a default multicaster of type `SimpleApplicationEventMulticaster` will be used.

Implements resource loading by extending `DefaultResourceLoader`. Consequently treats non-URL resource paths as class path resources (supporting full class path resource names that include the package path, for example, "mypackage/myresource.dat"), unless the `DefaultResourceLoader.getResourceByPath(java.lang.String)` method is overridden in a subclass.

Since:
  January 21, 2001
Author:
  Rod Johnson, Juergen Hoeller, Mark Fisher, Stephane Nicoll, Sam Brannen, Sebastien Deleuze, Brian Clozel
See Also:
  - `refreshBeanFactory()`
  - `getBeanFactory()`
  - `BeanFactoryPostProcessor`
  - `BeanPostProcessor`
  - `ApplicationEventMulticaster`
  - `ApplicationListener`
  - `MessageSource`

## Nested Class Summary

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

`org.springframework.core.io.DefaultResourceLoader.ClassPathContextResource`

## Field Summary

Fields
Modifier and Type
Field
Description
`static final String`
`APPLICATION_EVENT_MULTICASTER_BEAN_NAME`
The name of the `ApplicationEventMulticaster` bean in the context.
`static final String`
`LIFECYCLE_PROCESSOR_BEAN_NAME`
The name of the `LifecycleProcessor` bean in the context.
`protected final org.apache.commons.logging.Log`
`logger`
Logger used by this class.
`static final String`
`MESSAGE_SOURCE_BEAN_NAME`
The name of the `MessageSource` bean in the context.

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

`FACTORY_BEAN_PREFIX, FACTORY_BEAN_PREFIX_CHAR`

### Fields inherited from interface org.springframework.context.ConfigurableApplicationContext

`APPLICATION_STARTUP_BEAN_NAME, BOOTSTRAP_EXECUTOR_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.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
`AbstractApplicationContext()`
Create a new AbstractApplicationContext with no parent.
`AbstractApplicationContext(ApplicationContext parent)`
Create a new AbstractApplicationContext with the given parent context.

## Method Summary

Modifier and Type
Method
Description
`void`
`addApplicationListener(ApplicationListener<?> listener)`
Add a new ApplicationListener that will be notified on context events such as context refresh and context shutdown.
`void`
`addBeanFactoryPostProcessor(org.springframework.beans.factory.config.BeanFactoryPostProcessor postProcessor)`
Add a new BeanFactoryPostProcessor that will get applied to the internal bean factory of this application context on refresh, before any of the bean definitions get evaluated.
`protected void`
`assertBeanFactoryActive()`
Assert that this context's BeanFactory is currently active, throwing an `IllegalStateException` if it isn't.
`protected void`
`cancelRefresh(Throwable ex)`
Cancel this context's refresh attempt, resetting the `active` flag after an exception got thrown.
`void`
`clearResourceCaches()`
`void`
`close()`
Close this application context, destroying all beans in its bean factory.
`protected abstract void`
`closeBeanFactory()`
Subclasses must implement this method to release their internal bean factory.
`boolean`
`containsBean(String name)`
`boolean`
`containsBeanDefinition(String beanName)`
`boolean`
`containsLocalBean(String name)`
`protected org.springframework.core.env.ConfigurableEnvironment`
`createEnvironment()`
Create and return a new `StandardEnvironment`.
`protected void`
`destroyBeans()`
Template method for destroying all beans that this context manages.
`protected void`
`doClose()`
Actually performs context closing: publishes a ContextClosedEvent and destroys the singletons in the bean factory of this application context.
`<A extends Annotation>
Set<A>`
`findAllAnnotationsOnBean(String beanName, Class<A> annotationType, boolean allowFactoryBeanInit)`
`<A extends Annotation>
A`
`findAnnotationOnBean(String beanName, Class<A> annotationType)`
`<A extends Annotation>
A`
`findAnnotationOnBean(String beanName, Class<A> annotationType, boolean allowFactoryBeanInit)`
`protected void`
`finishBeanFactoryInitialization(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)`
Finish the initialization of this context's bean factory, initializing all remaining singleton beans.
`protected void`
`finishRefresh()`
Finish the refresh of this context, invoking the LifecycleProcessor's onRefresh() method and publishing the `ContextRefreshedEvent`.
`String[]`
`getAliases(String name)`
`Collection<ApplicationListener<?>>`
`getApplicationListeners()`
Return the list of statically specified ApplicationListeners.
`String`
`getApplicationName()`
Return a name for the deployed application that this context belongs to.
`org.springframework.core.metrics.ApplicationStartup`
`getApplicationStartup()`
Return the `ApplicationStartup` for this application context.
`org.springframework.beans.factory.config.AutowireCapableBeanFactory`
`getAutowireCapableBeanFactory()`
Return this context's internal bean factory as AutowireCapableBeanFactory, if already available.
`<T> T`
`getBean(Class<T> requiredType)`
`<T> T`
`getBean(Class<T> requiredType, Object... args)`
`Object`
`getBean(String name)`
`<T> T`
`getBean(String name, Class<T> requiredType)`
`Object`
`getBean(String name, Object... args)`
`int`
`getBeanDefinitionCount()`
`String[]`
`getBeanDefinitionNames()`
`abstract org.springframework.beans.factory.config.ConfigurableListableBeanFactory`
`getBeanFactory()`
Subclasses must return their internal bean factory here.
`List<org.springframework.beans.factory.config.BeanFactoryPostProcessor>`
`getBeanFactoryPostProcessors()`
Return the list of BeanFactoryPostProcessors that will get applied to the internal BeanFactory.
`String[]`
`getBeanNamesForAnnotation(Class<? extends Annotation> annotationType)`
`String[]`
`getBeanNamesForType(Class<?> type)`
`String[]`
`getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit)`
`String[]`
`getBeanNamesForType(org.springframework.core.ResolvableType type)`
`String[]`
`getBeanNamesForType(org.springframework.core.ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)`
`<T> org.springframework.beans.factory.ObjectProvider<T>`
`getBeanProvider(Class<T> requiredType)`
`<T> org.springframework.beans.factory.ObjectProvider<T>`
`getBeanProvider(Class<T> requiredType, boolean allowEagerInit)`
`<T> org.springframework.beans.factory.ObjectProvider<T>`
`getBeanProvider(org.springframework.core.ResolvableType requiredType)`
`<T> org.springframework.beans.factory.ObjectProvider<T>`
`getBeanProvider(org.springframework.core.ResolvableType requiredType, boolean allowEagerInit)`
`<T> Map<String,T>`
`getBeansOfType(Class<T> type)`
`<T> Map<String,T>`
`getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)`
`Map<String,Object>`
`getBeansWithAnnotation(Class<? extends Annotation> annotationType)`
`String`
`getDisplayName()`
Return a friendly name for this context.
`org.springframework.core.env.ConfigurableEnvironment`
`getEnvironment()`
Return the `Environment` for this application context in configurable form, allowing for further customization.
`String`
`getId()`
Return the unique id of this application context.
`protected org.springframework.beans.factory.BeanFactory`
`getInternalParentBeanFactory()`
Return the internal bean factory of the parent context if it implements ConfigurableApplicationContext; else, return the parent context itself.
`protected MessageSource`
`getInternalParentMessageSource()`
Return the internal message source of the parent context if it is an AbstractApplicationContext too; else, return the parent context itself.
`String`
`getMessage(String code, Object[] args, String defaultMessage, Locale locale)`
Try to resolve the message.
`String`
`getMessage(String code, Object[] args, Locale locale)`
Try to resolve the message.
`String`
`getMessage(MessageSourceResolvable resolvable, Locale locale)`
Try to resolve the message using all the attributes contained within the `MessageSourceResolvable` argument that was passed in.
`ApplicationContext`
`getParent()`
Return the parent context, or `null` if there is no parent (that is, this context is the root of the context hierarchy).
`org.springframework.beans.factory.BeanFactory`
`getParentBeanFactory()`
`protected org.springframework.core.io.support.ResourcePatternResolver`
`getResourcePatternResolver()`
Return the ResourcePatternResolver to use for resolving location patterns into Resource instances.
`org.springframework.core.io.Resource[]`
`getResources(String locationPattern)`
`long`
`getStartupDate()`
Return the timestamp (ms) when this context was first loaded.
`Class<?>`
`getType(String name)`
`Class<?>`
`getType(String name, boolean allowFactoryBeanInit)`
`protected void`
`initApplicationEventMulticaster()`
Initialize the `ApplicationEventMulticaster`.
`protected void`
`initLifecycleProcessor()`
Initialize the `LifecycleProcessor`.
`protected void`
`initMessageSource()`
Initialize the `MessageSource`.
`protected void`
`initPropertySources()`
Replace any stub property sources with actual instances.
`protected void`
`invokeBeanFactoryPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)`
Instantiate and invoke all registered BeanFactoryPostProcessor beans, respecting explicit order if given.
`boolean`
`isActive()`
Determine whether this application context is active, that is, whether it has been refreshed at least once and has not been closed yet.
`boolean`
`isClosed()`
Return whether this context has been closed already, that is, whether `ConfigurableApplicationContext.close()` has been called on an active context in order to initiate its shutdown.
`boolean`
`isPrototype(String name)`
`boolean`
`isRunning()`
Check whether this component is currently running.
`boolean`
`isSingleton(String name)`
`boolean`
`isTypeMatch(String name, Class<?> typeToMatch)`
`boolean`
`isTypeMatch(String name, org.springframework.core.ResolvableType typeToMatch)`
`protected org.springframework.beans.factory.config.ConfigurableListableBeanFactory`
`obtainFreshBeanFactory()`
Tell the subclass to refresh the internal bean factory.
`protected void`
`onClose()`
Template method which can be overridden to add context-specific shutdown work.
`protected void`
`onRefresh()`
Template method which can be overridden to add context-specific refresh work.
`protected void`
`postProcessBeanFactory(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)`
Modify the application context's internal bean factory after its standard initialization.
`protected void`
`prepareBeanFactory(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)`
Configure the factory's standard context characteristics, such as the context's ClassLoader and post-processors.
`protected void`
`prepareRefresh()`
Prepare this context for refreshing, setting its startup date and active flag as well as performing any initialization of property sources.
`void`
`publishEvent(Object event)`
Publish the given event to all listeners.
`protected void`
`publishEvent(Object event, org.springframework.core.ResolvableType typeHint)`
Publish the given event to all listeners.
`void`
`publishEvent(ApplicationEvent event)`
Publish the given event to all listeners.
`void`
`refresh()`
Load or refresh the persistent representation of the configuration, which might be from Java-based configuration, an XML file, a properties file, a relational database schema, or some other format.
`protected abstract void`
`refreshBeanFactory()`
Subclasses must implement this method to perform the actual configuration load.
`protected void`
`registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)`
Instantiate and register all BeanPostProcessor beans, respecting explicit order if given.
`protected void`
`registerListeners()`
Add beans that implement ApplicationListener as listeners.
`void`
`registerShutdownHook()`
Register a shutdown hook named `SpringContextShutdownHook` with the JVM runtime, closing this context on JVM shutdown unless it has already been closed at that time.
`void`
`removeApplicationListener(ApplicationListener<?> listener)`
Remove the given ApplicationListener from this context's set of listeners, assuming it got registered via `ConfigurableApplicationContext.addApplicationListener(org.springframework.context.ApplicationListener<?>)` before.
`protected void`
`resetCommonCaches()`
Reset Spring's common reflection metadata caches, in particular the `ReflectionUtils`, `AnnotationUtils`, `ResolvableType` and `CachedIntrospectionResults` caches.
`void`
`setApplicationStartup(org.springframework.core.metrics.ApplicationStartup applicationStartup)`
Set the `ApplicationStartup` for this application context.
`void`
`setDisplayName(String displayName)`
Set a friendly name for this context.
`void`
`setEnvironment(org.springframework.core.env.ConfigurableEnvironment environment)`
Set the `Environment` for this application context.
`void`
`setId(String id)`
Set the unique id of this application context.
`void`
`setParent(ApplicationContext parent)`
Set the parent of this application context.
`void`
`start()`
Start this component.
`void`
`stop()`
Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method.
`String`
`toString()`
Return information about this context.

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

`addProtocolResolver, 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`

## Field Details

### MESSAGE_SOURCE_BEAN_NAME

public static final String MESSAGE_SOURCE_BEAN_NAME
The name of the `MessageSource` bean in the context. If none is supplied, message resolution is delegated to the parent.

See Also:
  - `MessageSource`
  - `ResourceBundleMessageSource`
  - `ReloadableResourceBundleMessageSource`
  - `getMessage(MessageSourceResolvable, Locale)`
  - Constant Field Values

### APPLICATION_EVENT_MULTICASTER_BEAN_NAME

public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME
The name of the `ApplicationEventMulticaster` bean in the context. If none is supplied, a `SimpleApplicationEventMulticaster` is used.

See Also:
  - `ApplicationEventMulticaster`
  - `SimpleApplicationEventMulticaster`
  - `publishEvent(ApplicationEvent)`
  - `addApplicationListener(ApplicationListener)`
  - Constant Field Values

### LIFECYCLE_PROCESSOR_BEAN_NAME

public static final String LIFECYCLE_PROCESSOR_BEAN_NAME
The name of the `LifecycleProcessor` bean in the context. If none is supplied, a `DefaultLifecycleProcessor` is used.

Since:
  3.0
See Also:
  - `LifecycleProcessor`
  - `DefaultLifecycleProcessor`
  - `start()`
  - `stop()`
  - Constant Field Values

### logger

protected final org.apache.commons.logging.Log logger
Logger used by this class. Available to subclasses.

## Constructor Details

### AbstractApplicationContext

public AbstractApplicationContext()
Create a new AbstractApplicationContext with no parent.

### AbstractApplicationContext

public AbstractApplicationContext(@Nullable ApplicationContext parent)
Create a new AbstractApplicationContext with the given parent context.

Parameters:
  `parent` - the parent context

## Method Details

### setId

public void setId(String id)
Set the unique id of this application context.

Default is the object id of the context instance, or the name of the context bean if the context is itself defined as a bean.

Specified by:
  `setId` in interface `ConfigurableApplicationContext`
Parameters:
  `id` - the unique id of the context

### getId

public String getId()
Description copied from interface: `ApplicationContext`
Return the unique id of this application context.

Specified by:
  `getId` in interface `ApplicationContext`
Returns:
  the unique id of the context, or `null` if none

### getApplicationName

public String getApplicationName()
Description copied from interface: `ApplicationContext`
Return a name for the deployed application that this context belongs to.

Specified by:
  `getApplicationName` in interface `ApplicationContext`
Returns:
  a name for the deployed application, or the empty String by default

### setDisplayName

public void setDisplayName(String displayName)
Set a friendly name for this context. Typically done during initialization of concrete context implementations.

Default is the object id of the context instance.

### getDisplayName

public String getDisplayName()
Return a friendly name for this context.

Specified by:
  `getDisplayName` in interface `ApplicationContext`
Returns:
  a display name for this context (never `null`)

### getParent

@Nullable public ApplicationContext getParent()
Return the parent context, or `null` if there is no parent (that is, this context is the root of the context hierarchy).

Specified by:
  `getParent` in interface `ApplicationContext`
Returns:
  the parent context, or `null` if there is no parent

### setEnvironment

public void setEnvironment(org.springframework.core.env.ConfigurableEnvironment environment)
Set the `Environment` for this application context.

Default value is determined by `createEnvironment()`. Replacing the default with this method is one option but configuration through `getEnvironment()` should also be considered. In either case, such modifications should be performed before `refresh()`.

Specified by:
  `setEnvironment` in interface `ConfigurableApplicationContext`
Parameters:
  `environment` - the new environment
See Also:
  - `createEnvironment()`

### getEnvironment

public org.springframework.core.env.ConfigurableEnvironment getEnvironment()
Return the `Environment` for this application context in configurable form, allowing for further customization.

If none specified, a default environment will be initialized via `createEnvironment()`.

Specified by:
  `getEnvironment` in interface `ConfigurableApplicationContext`
Specified by:
  `getEnvironment` in interface `org.springframework.core.env.EnvironmentCapable`

### createEnvironment

protected org.springframework.core.env.ConfigurableEnvironment createEnvironment()
Create and return a new `StandardEnvironment`.

Subclasses may override this method in order to supply a custom `ConfigurableEnvironment` implementation.

### getAutowireCapableBeanFactory

public org.springframework.beans.factory.config.AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException
Return this context's internal bean factory as AutowireCapableBeanFactory, if already available.

Specified by:
  `getAutowireCapableBeanFactory` in interface `ApplicationContext`
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 (for example, if `refresh()` has never been called), or if the context has been closed already
See Also:
  - `getBeanFactory()`

### getStartupDate

public long getStartupDate()
Return the timestamp (ms) when this context was first loaded.

Specified by:
  `getStartupDate` in interface `ApplicationContext`
Returns:
  the timestamp (ms) when this context was first loaded

### publishEvent

public void publishEvent(ApplicationEvent event)
Publish the given event to all listeners.

Note: Listeners get initialized after the MessageSource, to be able to access it within listener implementations. Thus, MessageSource implementations cannot publish events.

Specified by:
  `publishEvent` in interface `ApplicationEventPublisher`
Parameters:
  `event` - the event to publish (may be application-specific or a standard framework event)
See Also:
  - `ApplicationEventPublisher.publishEvent(Object)`
  - `ApplicationListener.supportsAsyncExecution()`
  - `ContextRefreshedEvent`
  - `ContextClosedEvent`

### publishEvent

public void publishEvent(Object event)
Publish the given event to all listeners.

Note: Listeners get initialized after the MessageSource, to be able to access it within listener implementations. Thus, MessageSource implementations cannot publish events.

Specified by:
  `publishEvent` in interface `ApplicationEventPublisher`
Parameters:
  `event` - the event to publish (may be an `ApplicationEvent` or a payload object to be turned into a `PayloadApplicationEvent`)
See Also:
  - `ApplicationEventPublisher.publishEvent(ApplicationEvent)`
  - `PayloadApplicationEvent`

### publishEvent

protected void publishEvent(Object event, @Nullable org.springframework.core.ResolvableType typeHint)
Publish the given event to all listeners.

This is the internal delegate that all other `publishEvent` methods refer to. It is not meant to be called directly but rather serves as a propagation mechanism between application contexts in a hierarchy, potentially overridden in subclasses for a custom propagation arrangement.

Parameters:
  `event` - the event to publish (may be an `ApplicationEvent` or a payload object to be turned into a `PayloadApplicationEvent`)
  `typeHint` - the resolved event type, if known. The implementation of this method also tolerates a payload type hint for a payload object to be turned into a `PayloadApplicationEvent`. However, the recommended way is to construct an actual event object via `PayloadApplicationEvent(Object, Object, ResolvableType)` instead for such scenarios.
Since:
  4.2
See Also:
  - `ApplicationEventMulticaster.multicastEvent(ApplicationEvent, ResolvableType)`

### setApplicationStartup

public void setApplicationStartup(org.springframework.core.metrics.ApplicationStartup applicationStartup)
Description copied from interface: `ConfigurableApplicationContext`
Set the `ApplicationStartup` for this application context.

This allows the application context to record metrics during startup.

Specified by:
  `setApplicationStartup` in interface `ConfigurableApplicationContext`
Parameters:
  `applicationStartup` - the new context event factory

### getApplicationStartup

public org.springframework.core.metrics.ApplicationStartup getApplicationStartup()
Description copied from interface: `ConfigurableApplicationContext`
Return the `ApplicationStartup` for this application context.

Specified by:
  `getApplicationStartup` in interface `ConfigurableApplicationContext`

### getResourcePatternResolver

protected org.springframework.core.io.support.ResourcePatternResolver getResourcePatternResolver()
Return the ResourcePatternResolver to use for resolving location patterns into Resource instances. Default is a `PathMatchingResourcePatternResolver`, supporting Ant-style location patterns.

Can be overridden in subclasses, for extended resolution strategies, for example in a web environment.

Do not call this when needing to resolve a location pattern. Call the context's `getResources` method instead, which will delegate to the ResourcePatternResolver.

Returns:
  the ResourcePatternResolver for this context
See Also:
  - `getResources(java.lang.String)`
  - `PathMatchingResourcePatternResolver`

### setParent

public void setParent(@Nullable ApplicationContext parent)
Set the parent of this application context.

The parent environment is merged with this (child) application context environment if the parent is non-`null` and its environment is an instance of `ConfigurableEnvironment`.

Specified by:
  `setParent` in interface `ConfigurableApplicationContext`
Parameters:
  `parent` - the parent context
See Also:
  - `ConfigurableEnvironment.merge(ConfigurableEnvironment)`

### addBeanFactoryPostProcessor

public void addBeanFactoryPostProcessor(org.springframework.beans.factory.config.BeanFactoryPostProcessor postProcessor)
Description copied from interface: `ConfigurableApplicationContext`
Add a new BeanFactoryPostProcessor that will get applied to the internal bean factory of this application context on refresh, before any of the bean definitions get evaluated. To be invoked during context configuration.

Specified by:
  `addBeanFactoryPostProcessor` in interface `ConfigurableApplicationContext`
Parameters:
  `postProcessor` - the factory processor to register

### getBeanFactoryPostProcessors

public List<org.springframework.beans.factory.config.BeanFactoryPostProcessor> getBeanFactoryPostProcessors()
Return the list of BeanFactoryPostProcessors that will get applied to the internal BeanFactory.

### addApplicationListener

public void addApplicationListener(ApplicationListener<?> listener)
Description copied from interface: `ConfigurableApplicationContext`
Add a new ApplicationListener that will be notified on context events such as context refresh and context shutdown.

Note that any ApplicationListener registered here will be applied on refresh if the context is not active yet, or on the fly with the current event multicaster in case of a context that is already active.

Specified by:
  `addApplicationListener` in interface `ConfigurableApplicationContext`
Parameters:
  `listener` - the ApplicationListener to register
See Also:
  - `ContextRefreshedEvent`
  - `ContextClosedEvent`

### removeApplicationListener

public void removeApplicationListener(ApplicationListener<?> listener)
Description copied from interface: `ConfigurableApplicationContext`
Remove the given ApplicationListener from this context's set of listeners, assuming it got registered via `ConfigurableApplicationContext.addApplicationListener(org.springframework.context.ApplicationListener<?>)` before.

Specified by:
  `removeApplicationListener` in interface `ConfigurableApplicationContext`
Parameters:
  `listener` - the ApplicationListener to deregister

### getApplicationListeners

public Collection<ApplicationListener<?>> getApplicationListeners()
Return the list of statically specified ApplicationListeners.

### refresh

public void refresh() throws org.springframework.beans.BeansException, IllegalStateException
Description copied from interface: `ConfigurableApplicationContext`
Load or refresh the persistent representation of the configuration, which might be from Java-based configuration, an XML file, a properties file, a relational database schema, or some other format.

As this is a startup method, it should destroy already created singletons if it fails, to avoid dangling resources. In other words, after invocation of this method, either all or no singletons at all should be instantiated.

Specified by:
  `refresh` in interface `ConfigurableApplicationContext`
Throws:
  `org.springframework.beans.BeansException` - if the bean factory could not be initialized
  `IllegalStateException` - if already initialized and multiple refresh attempts are not supported

### prepareRefresh

protected void prepareRefresh()
Prepare this context for refreshing, setting its startup date and active flag as well as performing any initialization of property sources.

### initPropertySources

protected void initPropertySources()

Replace any stub property sources with actual instances.

See Also:
  - `PropertySource.StubPropertySource`
  - `org.springframework.web.context.support.WebApplicationContextUtils#initServletPropertySources`

### obtainFreshBeanFactory

protected org.springframework.beans.factory.config.ConfigurableListableBeanFactory obtainFreshBeanFactory()
Tell the subclass to refresh the internal bean factory.

Returns:
  the fresh BeanFactory instance
See Also:
  - `refreshBeanFactory()`
  - `getBeanFactory()`

### prepareBeanFactory

protected void prepareBeanFactory(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)
Configure the factory's standard context characteristics, such as the context's ClassLoader and post-processors.

Parameters:
  `beanFactory` - the BeanFactory to configure

### postProcessBeanFactory

protected void postProcessBeanFactory(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)
Modify the application context's internal bean factory after its standard initialization. The initial definition resources will have been loaded but no post-processors will have run and no derived bean definitions will have been registered, and most importantly, no beans will have been instantiated yet.

This template method allows for registering special BeanPostProcessors etc in certain AbstractApplicationContext subclasses.

Parameters:
  `beanFactory` - the bean factory used by the application context

### invokeBeanFactoryPostProcessors

protected void invokeBeanFactoryPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)
Instantiate and invoke all registered BeanFactoryPostProcessor beans, respecting explicit order if given.

Must be called before singleton instantiation.

### registerBeanPostProcessors

protected void registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)
Instantiate and register all BeanPostProcessor beans, respecting explicit order if given.

Must be called before any instantiation of application beans.

### initMessageSource

protected void initMessageSource()
Initialize the `MessageSource`.

Uses parent's `MessageSource` if none defined in this context.

See Also:
  - `MESSAGE_SOURCE_BEAN_NAME`

### initApplicationEventMulticaster

protected void initApplicationEventMulticaster()
Initialize the `ApplicationEventMulticaster`.

Uses `SimpleApplicationEventMulticaster` if none defined in the context.

See Also:
  - `APPLICATION_EVENT_MULTICASTER_BEAN_NAME`
  - `SimpleApplicationEventMulticaster`

### initLifecycleProcessor

protected void initLifecycleProcessor()
Initialize the `LifecycleProcessor`.

Uses `DefaultLifecycleProcessor` if none defined in the context.

Since:
  3.0
See Also:
  - `LIFECYCLE_PROCESSOR_BEAN_NAME`
  - `DefaultLifecycleProcessor`

### onRefresh

protected void onRefresh() throws org.springframework.beans.BeansException
Template method which can be overridden to add context-specific refresh work. Called on initialization of special beans, before instantiation of singletons.

This implementation is empty.

Throws:
  `org.springframework.beans.BeansException` - in case of errors
See Also:
  - `refresh()`

### registerListeners

protected void registerListeners()
Add beans that implement ApplicationListener as listeners. Doesn't affect other listeners, which can be added without being beans.

### finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory)
Finish the initialization of this context's bean factory, initializing all remaining singleton beans.

### finishRefresh

protected void finishRefresh()
Finish the refresh of this context, invoking the LifecycleProcessor's onRefresh() method and publishing the `ContextRefreshedEvent`.

### cancelRefresh

protected void cancelRefresh(Throwable ex)
Cancel this context's refresh attempt, resetting the `active` flag after an exception got thrown.

Parameters:
  `ex` - the exception that led to the cancellation

### resetCommonCaches

protected void resetCommonCaches()
Reset Spring's common reflection metadata caches, in particular the `ReflectionUtils`, `AnnotationUtils`, `ResolvableType` and `CachedIntrospectionResults` caches.

Since:
  4.2
See Also:
  - `ReflectionUtils.clearCache()`
  - `AnnotationUtils.clearCache()`
  - `ResolvableType.clearCache()`
  - `CachedIntrospectionResults.clearClassLoader(ClassLoader)`

### clearResourceCaches

public void clearResourceCaches()

Overrides:
  `clearResourceCaches` in class `org.springframework.core.io.DefaultResourceLoader`

### registerShutdownHook

public void registerShutdownHook()
Register a shutdown hook named `SpringContextShutdownHook` with the JVM runtime, closing this context on JVM shutdown unless it has already been closed at that time.

Delegates to `doClose()` for the actual closing procedure.

Specified by:
  `registerShutdownHook` in interface `ConfigurableApplicationContext`
See Also:
  - `Runtime.addShutdownHook(java.lang.Thread)`
  - `ConfigurableApplicationContext.SHUTDOWN_HOOK_THREAD_NAME`
  - `close()`
  - `doClose()`

### close

public void close()
Close this application context, destroying all beans in its bean factory.

Delegates to `doClose()` for the actual closing procedure. Also removes a JVM shutdown hook, if registered, as it's not needed anymore.

Specified by:
  `close` in interface `AutoCloseable`
Specified by:
  `close` in interface `Closeable`
Specified by:
  `close` in interface `ConfigurableApplicationContext`
See Also:
  - `doClose()`
  - `registerShutdownHook()`

### doClose

protected void doClose()
Actually performs context closing: publishes a ContextClosedEvent and destroys the singletons in the bean factory of this application context.

Called by both `close()` and a JVM shutdown hook, if any.

See Also:
  - `ContextClosedEvent`
  - `destroyBeans()`
  - `close()`
  - `registerShutdownHook()`

### destroyBeans

protected void destroyBeans()
Template method for destroying all beans that this context manages. The default implementation destroy all cached singletons in this context, invoking `DisposableBean.destroy()` and/or the specified "destroy-method".

Can be overridden to add context-specific bean destruction steps right before or right after standard singleton destruction, while the context's BeanFactory is still active.

See Also:
  - `getBeanFactory()`
  - `ConfigurableBeanFactory.destroySingletons()`

### onClose

protected void onClose()
Template method which can be overridden to add context-specific shutdown work. The default implementation is empty.

Called at the end of `doClose()`'s shutdown procedure, after this context's BeanFactory has been closed. If custom shutdown logic needs to execute while the BeanFactory is still active, override the `destroyBeans()` method instead.

### isClosed

public boolean isClosed()
Description copied from interface: `ConfigurableApplicationContext`
Return whether this context has been closed already, that is, whether `ConfigurableApplicationContext.close()` has been called on an active context in order to initiate its shutdown.

Note: This does not indicate whether context shutdown has completed. Use `ConfigurableApplicationContext.isActive()` for differentiating between those scenarios: a context becomes inactive once it has been fully shut down and the original `close()` call has returned.

Specified by:
  `isClosed` in interface `ConfigurableApplicationContext`

### isActive

public boolean isActive()
Description copied from interface: `ConfigurableApplicationContext`
Determine whether this application context is active, that is, whether it has been refreshed at least once and has not been closed yet.

Specified by:
  `isActive` in interface `ConfigurableApplicationContext`
Returns:
  whether the context is still active
See Also:
  - `ConfigurableApplicationContext.refresh()`
  - `ConfigurableApplicationContext.close()`
  - `ConfigurableApplicationContext.getBeanFactory()`

### assertBeanFactoryActive

protected void assertBeanFactoryActive()
Assert that this context's BeanFactory is currently active, throwing an `IllegalStateException` if it isn't.

Invoked by all `BeanFactory` delegation methods that depend on an active context, i.e. in particular all bean accessor methods.

The default implementation checks the `'active'` status of this context overall. May be overridden for more specific checks, or for a no-op if `getBeanFactory()` itself throws an exception in such a case.

### getBean

public Object getBean(String name) throws org.springframework.beans.BeansException

Specified by:
  `getBean` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.BeansException`

### getBean

public <T> T getBean(String name, Class<T> requiredType) throws org.springframework.beans.BeansException

Specified by:
  `getBean` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.BeansException`

### getBean

public Object getBean(String name, Object... args) throws org.springframework.beans.BeansException

Specified by:
  `getBean` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.BeansException`

### getBean

public <T> T getBean(Class<T> requiredType) throws org.springframework.beans.BeansException

Specified by:
  `getBean` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.BeansException`

### getBean

public <T> T getBean(Class<T> requiredType, Object... args) throws org.springframework.beans.BeansException

Specified by:
  `getBean` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.BeansException`

### getBeanProvider

public <T> org.springframework.beans.factory.ObjectProvider<T> getBeanProvider(Class<T> requiredType)

Specified by:
  `getBeanProvider` in interface `org.springframework.beans.factory.BeanFactory`

### getBeanProvider

public <T> org.springframework.beans.factory.ObjectProvider<T> getBeanProvider(org.springframework.core.ResolvableType requiredType)

Specified by:
  `getBeanProvider` in interface `org.springframework.beans.factory.BeanFactory`

### containsBean

public boolean containsBean(String name)

Specified by:
  `containsBean` in interface `org.springframework.beans.factory.BeanFactory`

### isSingleton

public boolean isSingleton(String name) throws org.springframework.beans.factory.NoSuchBeanDefinitionException

Specified by:
  `isSingleton` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.factory.NoSuchBeanDefinitionException`

### isPrototype

public boolean isPrototype(String name) throws org.springframework.beans.factory.NoSuchBeanDefinitionException

Specified by:
  `isPrototype` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.factory.NoSuchBeanDefinitionException`

### isTypeMatch

public boolean isTypeMatch(String name, org.springframework.core.ResolvableType typeToMatch) throws org.springframework.beans.factory.NoSuchBeanDefinitionException

Specified by:
  `isTypeMatch` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.factory.NoSuchBeanDefinitionException`

### isTypeMatch

public boolean isTypeMatch(String name, Class<?> typeToMatch) throws org.springframework.beans.factory.NoSuchBeanDefinitionException

Specified by:
  `isTypeMatch` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.factory.NoSuchBeanDefinitionException`

### getType

@Nullable public Class<?> getType(String name) throws org.springframework.beans.factory.NoSuchBeanDefinitionException

Specified by:
  `getType` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.factory.NoSuchBeanDefinitionException`

### getType

@Nullable public Class<?> getType(String name, boolean allowFactoryBeanInit) throws org.springframework.beans.factory.NoSuchBeanDefinitionException

Specified by:
  `getType` in interface `org.springframework.beans.factory.BeanFactory`
Throws:
  `org.springframework.beans.factory.NoSuchBeanDefinitionException`

### getAliases

public String[] getAliases(String name)

Specified by:
  `getAliases` in interface `org.springframework.beans.factory.BeanFactory`

### containsBeanDefinition

public boolean containsBeanDefinition(String beanName)

Specified by:
  `containsBeanDefinition` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeanDefinitionCount

public int getBeanDefinitionCount()

Specified by:
  `getBeanDefinitionCount` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeanDefinitionNames

public String[] getBeanDefinitionNames()

Specified by:
  `getBeanDefinitionNames` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeanProvider

public <T> org.springframework.beans.factory.ObjectProvider<T> getBeanProvider(Class<T> requiredType, boolean allowEagerInit)

Specified by:
  `getBeanProvider` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeanProvider

public <T> org.springframework.beans.factory.ObjectProvider<T> getBeanProvider(org.springframework.core.ResolvableType requiredType, boolean allowEagerInit)

Specified by:
  `getBeanProvider` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeanNamesForType

public String[] getBeanNamesForType(org.springframework.core.ResolvableType type)

Specified by:
  `getBeanNamesForType` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeanNamesForType

public String[] getBeanNamesForType(org.springframework.core.ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)

Specified by:
  `getBeanNamesForType` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeanNamesForType

public String[] getBeanNamesForType(@Nullable Class<?> type)

Specified by:
  `getBeanNamesForType` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeanNamesForType

public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit)

Specified by:
  `getBeanNamesForType` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeansOfType

public <T> Map<String,T> getBeansOfType(@Nullable Class<T> type) throws org.springframework.beans.BeansException

Specified by:
  `getBeansOfType` in interface `org.springframework.beans.factory.ListableBeanFactory`
Throws:
  `org.springframework.beans.BeansException`

### getBeansOfType

public <T> Map<String,T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws org.springframework.beans.BeansException

Specified by:
  `getBeansOfType` in interface `org.springframework.beans.factory.ListableBeanFactory`
Throws:
  `org.springframework.beans.BeansException`

### getBeanNamesForAnnotation

public String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType)

Specified by:
  `getBeanNamesForAnnotation` in interface `org.springframework.beans.factory.ListableBeanFactory`

### getBeansWithAnnotation

public Map<String,Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws org.springframework.beans.BeansException

Specified by:
  `getBeansWithAnnotation` in interface `org.springframework.beans.factory.ListableBeanFactory`
Throws:
  `org.springframework.beans.BeansException`

### findAnnotationOnBean

@Nullable public <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws org.springframework.beans.factory.NoSuchBeanDefinitionException

Specified by:
  `findAnnotationOnBean` in interface `org.springframework.beans.factory.ListableBeanFactory`
Throws:
  `org.springframework.beans.factory.NoSuchBeanDefinitionException`

### findAnnotationOnBean

@Nullable public <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType, boolean allowFactoryBeanInit) throws org.springframework.beans.factory.NoSuchBeanDefinitionException

Specified by:
  `findAnnotationOnBean` in interface `org.springframework.beans.factory.ListableBeanFactory`
Throws:
  `org.springframework.beans.factory.NoSuchBeanDefinitionException`

### findAllAnnotationsOnBean

public <A extends Annotation> Set<A> findAllAnnotationsOnBean(String beanName, Class<A> annotationType, boolean allowFactoryBeanInit) throws org.springframework.beans.factory.NoSuchBeanDefinitionException

Specified by:
  `findAllAnnotationsOnBean` in interface `org.springframework.beans.factory.ListableBeanFactory`
Throws:
  `org.springframework.beans.factory.NoSuchBeanDefinitionException`

### getParentBeanFactory

@Nullable public org.springframework.beans.factory.BeanFactory getParentBeanFactory()

Specified by:
  `getParentBeanFactory` in interface `org.springframework.beans.factory.HierarchicalBeanFactory`

### containsLocalBean

public boolean containsLocalBean(String name)

Specified by:
  `containsLocalBean` in interface `org.springframework.beans.factory.HierarchicalBeanFactory`

### getInternalParentBeanFactory

@Nullable protected org.springframework.beans.factory.BeanFactory getInternalParentBeanFactory()
Return the internal bean factory of the parent context if it implements ConfigurableApplicationContext; else, return the parent context itself.

See Also:
  - `ConfigurableApplicationContext.getBeanFactory()`

### getMessage

@Nullable public String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, @Nullable Locale locale)
Description copied from interface: `MessageSource`
Try to resolve the message. Return default message if no message was found.

Specified by:
  `getMessage` in interface `MessageSource`
Parameters:
  `code` - the message code to look up, for example, 'calculator.noRateSet'. MessageSource users are encouraged to base message names on qualified class or package names, avoiding potential conflicts and ensuring maximum clarity.
  `args` - an array of arguments that will be filled in for params within the message (params look like "{0}", "{1,date}", "{2,time}" within a message), or `null` if none
  `defaultMessage` - a default message to return if the lookup fails
  `locale` - the locale in which to do the lookup
Returns:
  the resolved message if the lookup was successful, otherwise the default message passed as a parameter (which may be `null`)
See Also:
  - `MessageSource.getMessage(MessageSourceResolvable, Locale)`
  - `MessageFormat`

### getMessage

public String getMessage(String code, @Nullable Object[] args, @Nullable Locale locale) throws NoSuchMessageException
Description copied from interface: `MessageSource`
Try to resolve the message. Treat as an error if the message can't be found.

Specified by:
  `getMessage` in interface `MessageSource`
Parameters:
  `code` - the message code to look up, for example, 'calculator.noRateSet'. MessageSource users are encouraged to base message names on qualified class or package names, avoiding potential conflicts and ensuring maximum clarity.
  `args` - an array of arguments that will be filled in for params within the message (params look like "{0}", "{1,date}", "{2,time}" within a message), or `null` if none
  `locale` - the locale in which to do the lookup
Returns:
  the resolved message (never `null`)
Throws:
  `NoSuchMessageException` - if no corresponding message was found
See Also:
  - `MessageSource.getMessage(MessageSourceResolvable, Locale)`
  - `MessageFormat`

### getMessage

public String getMessage(MessageSourceResolvable resolvable, @Nullable Locale locale) throws NoSuchMessageException
Description copied from interface: `MessageSource`
Try to resolve the message using all the attributes contained within the `MessageSourceResolvable` argument that was passed in.

NOTE: We must throw a `NoSuchMessageException` on this method since at the time of calling this method we aren't able to determine if the `defaultMessage` property of the resolvable is `null` or not.

Specified by:
  `getMessage` in interface `MessageSource`
Parameters:
  `resolvable` - the value object storing attributes required to resolve a message (may include a default message)
  `locale` - the locale in which to do the lookup
Returns:
  the resolved message (never `null` since even a `MessageSourceResolvable`-provided default message needs to be non-null)
Throws:
  `NoSuchMessageException` - if no corresponding message was found (and no default message was provided by the `MessageSourceResolvable`)
See Also:
  - `MessageSourceResolvable.getCodes()`
  - `MessageSourceResolvable.getArguments()`
  - `MessageSourceResolvable.getDefaultMessage()`
  - `MessageFormat`

### getInternalParentMessageSource

@Nullable protected MessageSource getInternalParentMessageSource()
Return the internal message source of the parent context if it is an AbstractApplicationContext too; else, return the parent context itself.

### getResources

public org.springframework.core.io.Resource[] getResources(String locationPattern) throws IOException

Specified by:
  `getResources` in interface `org.springframework.core.io.support.ResourcePatternResolver`
Throws:
  `IOException`

### start

public void start()
Description copied from interface: `Lifecycle`
Start this component.

Should not throw an exception if the component is already running.

In the case of a container, this will propagate a hard start signal to all components that apply, even to non-auto-startup components.

Specified by:
  `start` in interface `Lifecycle`
See Also:
  - `SmartLifecycle.isAutoStartup()`

### stop

public void stop()
Description copied from interface: `Lifecycle`
Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method. Consider implementing `SmartLifecycle` and its `stop(Runnable)` variant when asynchronous stop behavior is necessary.

Note that this stop notification is not guaranteed to come before destruction: On regular shutdown, `Lifecycle` beans will first receive a stop notification before the general destruction callbacks are being propagated; however, on hot refresh during a context's lifetime or on aborted refresh attempts, a given bean's destroy method will be called without any consideration of stop signals upfront.

Should not throw an exception if the component is not running (not started yet).

In the case of a container, this will propagate the stop signal to all components that apply.

Specified by:
  `stop` in interface `Lifecycle`
See Also:
  - `SmartLifecycle.stop(Runnable)`
  - `DisposableBean.destroy()`

### isRunning

public boolean isRunning()
Description copied from interface: `Lifecycle`
Check whether this component is currently running.

In the case of a container, this will return `true` only if all components that apply are currently running.

Specified by:
  `isRunning` in interface `Lifecycle`
Returns:
  whether the component is currently running

### refreshBeanFactory

protected abstract void refreshBeanFactory() throws org.springframework.beans.BeansException, IllegalStateException
Subclasses must implement this method to perform the actual configuration load. The method is invoked by `refresh()` before any other initialization work.

A subclass will either create a new bean factory and hold a reference to it, or return a single BeanFactory instance that it holds. In the latter case, it will usually throw an IllegalStateException if refreshing the context more than once.

Throws:
  `org.springframework.beans.BeansException` - if initialization of the bean factory failed
  `IllegalStateException` - if already initialized and multiple refresh attempts are not supported

### closeBeanFactory

protected abstract void closeBeanFactory()
Subclasses must implement this method to release their internal bean factory. This method gets invoked by `close()` after all other shutdown work.

Should never throw an exception but rather log shutdown failures.

### getBeanFactory

public abstract org.springframework.beans.factory.config.ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException
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`
Returns:
  this application context's internal bean factory (never `null`)
Throws:
  `IllegalStateException` - if the context does not hold an internal bean factory yet (usually if `refresh()` has never been called) or if the context has been closed already
See Also:
  - `refreshBeanFactory()`
  - `closeBeanFactory()`

### toString

public String toString()
Return information about this context.

Overrides:
  `toString` in class `Object`