| Package | Description | 
|---|---|
| org.springframework.context | 
 This package builds on the beans package to add support for
 message sources and for the Observer design pattern, and the
 ability for application objects to obtain resources using a
 consistent API. 
 | 
| org.springframework.context.annotation | 
 Annotation support for the Application Context, including JSR-250 "common"
 annotations, component-scanning, and Java-based metadata for creating
 Spring-managed objects. 
 | 
| org.springframework.context.support | 
 Classes supporting the org.springframework.context package,
 such as abstract base classes for ApplicationContext
 implementations and a MessageSource implementation. 
 | 
| org.springframework.jca.context | 
 Integration package that allows for deploying a Spring application context
 as a JCA 1.7 compliant RAR file. 
 | 
| org.springframework.test.context | 
 This package contains the Spring TestContext Framework which
 provides annotation-driven unit and integration testing support that is
 agnostic of the actual testing framework in use. 
 | 
| org.springframework.test.context.support | 
 Support classes for the Spring TestContext Framework. 
 | 
| org.springframework.test.context.web | 
 Web support classes for the Spring TestContext Framework. 
 | 
| org.springframework.web.context | 
 Contains a variant of the application context interface for web applications,
 and the ContextLoaderListener that bootstraps a root web application context. 
 | 
| org.springframework.web.context.support | 
 Classes supporting the  
org.springframework.web.context package,
 such as WebApplicationContext implementations and various utility classes. | 
| org.springframework.web.servlet | 
 Provides servlets that integrate with the application context
 infrastructure, and the core interfaces and classes for the
 Spring web MVC framework. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
ApplicationContextInitializer<C extends ConfigurableApplicationContext>
Callback interface for initializing a Spring  
ConfigurableApplicationContext
 prior to being refreshed. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AnnotationConfigApplicationContext
Standalone application context, accepting component classes as input —
 in particular  
@Configuration-annotated classes, but also plain
 @Component types and JSR-330 compliant
 classes using javax.inject annotations. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AbstractApplicationContext
Abstract implementation of the  
ApplicationContext
 interface. | 
class  | 
AbstractRefreshableApplicationContext
Base class for  
ApplicationContext
 implementations which are supposed to support multiple calls to AbstractApplicationContext.refresh(),
 creating a new internal bean factory instance every time. | 
class  | 
AbstractRefreshableConfigApplicationContext
AbstractRefreshableApplicationContext subclass that adds common handling
 of specified config locations. | 
class  | 
AbstractXmlApplicationContext
Convenient base class for  
ApplicationContext
 implementations, drawing configuration from XML documents containing bean definitions
 understood by an XmlBeanDefinitionReader. | 
class  | 
ClassPathXmlApplicationContext
Standalone XML application context, taking the context definition files
 from the class path, interpreting plain paths as class path resource names
 that include the package path (e.g. 
 | 
class  | 
FileSystemXmlApplicationContext
Standalone XML application context, taking the context definition files
 from the file system or from URLs, interpreting plain paths as relative
 file system locations (e.g. 
 | 
class  | 
GenericApplicationContext
Generic ApplicationContext implementation that holds a single internal
  
DefaultListableBeanFactory
 instance and does not assume a specific bean definition format. | 
class  | 
GenericGroovyApplicationContext
An  
ApplicationContext implementation that extends
 GenericApplicationContext and implements GroovyObject such that beans
 can be retrieved with the dot de-reference syntax instead of using AbstractApplicationContext.getBean(java.lang.String). | 
class  | 
GenericXmlApplicationContext
Convenient application context with built-in XML support. 
 | 
class  | 
StaticApplicationContext
ApplicationContext implementation
 which supports programmatic registration of beans and messages,
 rather than reading bean definitions from external configuration sources. | 
| Modifier and Type | Method and Description | 
|---|---|
protected Set<ConfigurableApplicationContext> | 
LiveBeansView.findApplicationContexts()
Deprecated.  
Find all applicable ApplicationContexts for the current application. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected String | 
LiveBeansView.generateJson(Set<ConfigurableApplicationContext> contexts)
Deprecated.  
Actually generate a JSON snapshot of the beans in the given ApplicationContexts. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ResourceAdapterApplicationContext
ApplicationContext implementation
 for a JCA ResourceAdapter. | 
| Modifier and Type | Method and Description | 
|---|---|
protected ConfigurableApplicationContext | 
SpringContextResourceAdapter.createApplicationContext(BootstrapContext bootstrapContext)
Build a Spring ApplicationContext for the given JCA BootstrapContext. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ContextCustomizer.customizeContext(ConfigurableApplicationContext context,
                MergedContextConfiguration mergedConfig)
Customize the supplied  
ConfigurableApplicationContext after
 bean definitions have been loaded into the context but before the
 context has been refreshed. | 
| Modifier and Type | Method and Description | 
|---|---|
ConfigurableApplicationContext | 
AbstractGenericContextLoader.loadContext(MergedContextConfiguration mergedConfig)
Load a Spring ApplicationContext from the supplied  
MergedContextConfiguration. | 
ConfigurableApplicationContext | 
AbstractGenericContextLoader.loadContext(String... locations)
Load a Spring ApplicationContext from the supplied  
locations. | 
| Modifier and Type | Method and Description | 
|---|---|
static void | 
TestPropertySourceUtils.addInlinedPropertiesToEnvironment(ConfigurableApplicationContext context,
                                 String... inlinedProperties)
Add the given inlined properties to the  
Environment of the
 supplied context. | 
static void | 
TestPropertySourceUtils.addPropertiesFilesToEnvironment(ConfigurableApplicationContext context,
                               String... locations)
Add the  
Properties files from the given resource locations
 to the Environment of the supplied context. | 
protected void | 
AbstractContextLoader.customizeContext(ConfigurableApplicationContext context,
                MergedContextConfiguration mergedConfig)
Customize the  
ConfigurableApplicationContext created by this
 ContextLoader after bean definitions have been loaded
 into the context but before the context has been refreshed. | 
protected void | 
AbstractContextLoader.prepareContext(ConfigurableApplicationContext context,
              MergedContextConfiguration mergedConfig)
Prepare the  
ConfigurableApplicationContext created by this
 SmartContextLoader before bean definitions are read. | 
| Modifier and Type | Method and Description | 
|---|---|
ConfigurableApplicationContext | 
AbstractGenericWebContextLoader.loadContext(MergedContextConfiguration mergedConfig)
Load a Spring  
WebApplicationContext from the supplied
 MergedContextConfiguration. | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
ConfigurableWebApplicationContext
Interface to be implemented by configurable web application contexts. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> | 
ContextLoader.determineContextInitializerClasses(ServletContext servletContext)
Return the  
ApplicationContextInitializer implementation classes to use
 if any have been specified by ContextLoader.CONTEXT_INITIALIZER_CLASSES_PARAM. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AbstractRefreshableWebApplicationContext
AbstractRefreshableApplicationContext
 subclass which implements the
 ConfigurableWebApplicationContext
 interface for web environments. | 
class  | 
AnnotationConfigWebApplicationContext
WebApplicationContext
 implementation which accepts component classes as input — in particular
 @Configuration-annotated
 classes, but also plain @Component
 classes and JSR-330 compliant classes using javax.inject annotations. | 
class  | 
GenericWebApplicationContext
Subclass of  
GenericApplicationContext, suitable for web environments. | 
class  | 
GroovyWebApplicationContext
WebApplicationContext implementation which takes
 its configuration from Groovy bean definition scripts and/or XML files, as understood by
 a GroovyBeanDefinitionReader. | 
class  | 
StaticWebApplicationContext
Static  
WebApplicationContext
 implementation for testing. | 
class  | 
XmlWebApplicationContext
WebApplicationContext implementation
 which takes its configuration from XML documents, understood by an
 XmlBeanDefinitionReader. | 
| Modifier and Type | Method and Description | 
|---|---|
protected Set<ConfigurableApplicationContext> | 
ServletContextLiveBeansView.findApplicationContexts()
Deprecated.  
  | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
FrameworkServlet.applyInitializers(ConfigurableApplicationContext wac)
Delegate the WebApplicationContext before it is refreshed to any
  
ApplicationContextInitializer instances specified by the
 "contextInitializerClasses" servlet init-param. |