| 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.event | 
 Support classes for application events, like standard context events. 
 | 
| 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.http.converter.json | 
 Provides HttpMessageConverter implementations for handling JSON. 
 | 
| org.springframework.jca.context | 
 Integration package that allows for deploying a Spring application context
 as a JCA 1.7 compliant RAR file. 
 | 
| org.springframework.jms.config | 
 Support package for declarative messaging configuration,
 with Java configuration and XML schema support. 
 | 
| org.springframework.messaging.handler.invocation | 
 Common infrastructure for invoking message handler methods. 
 | 
| org.springframework.messaging.handler.invocation.reactive | 
 Common infrastructure for invoking message handler methods with non-blocking,
 and reactive contracts. 
 | 
| org.springframework.messaging.simp.config | 
 Configuration support for WebSocket messaging using higher level messaging protocols. 
 | 
| org.springframework.scheduling.annotation | 
 Java 5 annotation for asynchronous method execution. 
 | 
| org.springframework.scheduling.quartz | 
 Support classes for the open source scheduler
 Quartz,
 allowing to set up Quartz Schedulers, JobDetails and
 Triggers as beans in a Spring context. 
 | 
| 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.cache | 
 Support for context caching within the Spring TestContext Framework. 
 | 
| org.springframework.test.context.junit.jupiter | 
 Core support for integrating the Spring TestContext Framework
 with the JUnit Jupiter extension model in JUnit 5. 
 | 
| org.springframework.test.context.junit4 | 
 Support classes for integrating the Spring TestContext Framework
 with JUnit 4.12 or higher. 
 | 
| org.springframework.test.context.support | 
 Support classes for the Spring TestContext Framework. 
 | 
| org.springframework.test.context.testng | 
 Support classes for integrating the Spring TestContext Framework
 with TestNG. 
 | 
| org.springframework.test.context.web | 
 Web support classes for the Spring TestContext Framework. 
 | 
| org.springframework.test.web.reactive.server | 
 Support for testing Spring WebFlux server endpoints via
  
WebTestClient. | 
| org.springframework.ui.context.support | 
 Classes supporting the org.springframework.ui.context package. 
 | 
| org.springframework.validation.beanvalidation | 
 Support classes for integrating a JSR-303 Bean Validation provider
 (such as Hibernate Validator) into a Spring ApplicationContext
 and in particular with Spring's data binding and validation APIs. 
 | 
| 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.method | 
 Common infrastructure for handler method processing, as used by
 Spring MVC's  
org.springframework.web.servlet.mvc.method package. | 
| org.springframework.web.reactive | 
 Top-level package for the  
spring-webflux module that contains
 DispatcherHandler, the main entry
 point for WebFlux server endpoint processing including key contracts used to
 map requests to handlers, invoke them, and process the result. | 
| org.springframework.web.reactive.config | 
 Spring WebFlux configuration infrastructure. 
 | 
| org.springframework.web.reactive.result.method.annotation | 
 Infrastructure for annotation-based handler method processing. 
 | 
| org.springframework.web.reactive.result.view | 
 Support for result handling through view resolution. 
 | 
| org.springframework.web.reactive.result.view.script | 
 Support classes for views based on the JSR-223 script engine abstraction
 (as included in Java 6+), e.g. 
 | 
| org.springframework.web.server | 
 Core interfaces and classes for Spring's generic, reactive web support. 
 | 
| org.springframework.web.server.adapter | 
 Implementations to adapt to the underlying
  
org.springframework.http.client.reactive reactive HTTP adapter
 and HttpHandler. | 
| 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. 
 | 
| org.springframework.web.servlet.config.annotation | 
 Annotation-based setup for Spring MVC. 
 | 
| org.springframework.web.servlet.handler | 
 Provides standard HandlerMapping implementations,
 including abstract base classes for custom implementations. 
 | 
| org.springframework.web.servlet.mvc.method.annotation | 
 MVC infrastructure for annotation-based handler method processing, building on the
  
org.springframework.web.method.annotation package. | 
| org.springframework.web.servlet.resource | 
 Support classes for serving static resources. 
 | 
| org.springframework.web.servlet.view | 
 Provides standard View and ViewResolver implementations,
 including abstract base classes for custom implementations. 
 | 
| org.springframework.web.servlet.view.groovy | 
 Support classes for the integration of
 
 Groovy Templates as Spring web view technology. 
 | 
| org.springframework.web.servlet.view.script | 
 Support classes for views based on the JSR-223 script engine abstraction
 (as included in Java 6+), e.g. 
 | 
| org.springframework.web.socket.adapter.standard | 
 Adapter classes for the standard Java WebSocket API. 
 | 
| org.springframework.web.socket.config.annotation | 
 Support for annotation-based WebSocket setup in configuration classes. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
ConfigurableApplicationContext
SPI interface to be implemented by most if not all application contexts. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
ApplicationContext.getParent()
Return the parent context, or  
null if there is no parent
 and this is the root of the context hierarchy. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ApplicationContextAware.setApplicationContext(ApplicationContext applicationContext)
Set the ApplicationContext that this object runs in. 
 | 
void | 
ConfigurableApplicationContext.setParent(ApplicationContext parent)
Set the parent of this application context. 
 | 
| 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 | Method and Description | 
|---|---|
ApplicationContext | 
ApplicationContextEvent.getApplicationContext()
Get the  
ApplicationContext that the event was raised for. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
EventListenerMethodProcessor.setApplicationContext(ApplicationContext applicationContext)  | 
| Constructor and Description | 
|---|
ApplicationContextEvent(ApplicationContext source)
Create a new ContextStartedEvent. 
 | 
ContextClosedEvent(ApplicationContext source)
Creates a new ContextClosedEvent. 
 | 
ContextRefreshedEvent(ApplicationContext source)
Create a new ContextRefreshedEvent. 
 | 
ContextStartedEvent(ApplicationContext source)
Create a new ContextStartedEvent. 
 | 
ContextStoppedEvent(ApplicationContext source)
Create a new ContextStoppedEvent. 
 | 
| 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 | 
|---|---|
ApplicationContext | 
ApplicationObjectSupport.getApplicationContext()
Return the ApplicationContext that this object is associated with. 
 | 
ApplicationContext | 
AbstractApplicationContext.getParent()
Return the parent context, or  
null if there is no parent
 (that is, this context is the root of the context hierarchy). | 
protected ApplicationContext | 
ApplicationObjectSupport.obtainApplicationContext()
Obtain the ApplicationContext for actual use. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
ApplicationObjectSupport.initApplicationContext(ApplicationContext context)
Subclasses can override this for custom initialization behavior. 
 | 
void | 
LiveBeansView.setApplicationContext(ApplicationContext applicationContext)
Deprecated.  
  | 
void | 
ApplicationObjectSupport.setApplicationContext(ApplicationContext context)  | 
void | 
GenericApplicationContext.setParent(ApplicationContext parent)
Set the parent of this application context, also setting
 the parent of the internal BeanFactory accordingly. 
 | 
void | 
AbstractApplicationContext.setParent(ApplicationContext parent)
Set the parent of this application context. 
 | 
| Constructor and Description | 
|---|
AbstractApplicationContext(ApplicationContext parent)
Create a new AbstractApplicationContext with the given parent context. 
 | 
AbstractRefreshableApplicationContext(ApplicationContext parent)
Create a new AbstractRefreshableApplicationContext with the given parent context. 
 | 
AbstractRefreshableConfigApplicationContext(ApplicationContext parent)
Create a new AbstractRefreshableConfigApplicationContext with the given parent context. 
 | 
AbstractXmlApplicationContext(ApplicationContext parent)
Create a new AbstractXmlApplicationContext with the given parent context. 
 | 
ClassPathXmlApplicationContext(ApplicationContext parent)
Create a new ClassPathXmlApplicationContext for bean-style configuration. 
 | 
ClassPathXmlApplicationContext(String[] configLocations,
                              ApplicationContext parent)
Create a new ClassPathXmlApplicationContext with the given parent,
 loading the definitions from the given XML files and automatically
 refreshing the context. 
 | 
ClassPathXmlApplicationContext(String[] configLocations,
                              boolean refresh,
                              ApplicationContext parent)
Create a new ClassPathXmlApplicationContext with the given parent,
 loading the definitions from the given XML files. 
 | 
ClassPathXmlApplicationContext(String[] paths,
                              Class<?> clazz,
                              ApplicationContext parent)
Create a new ClassPathXmlApplicationContext with the given parent,
 loading the definitions from the given XML files and automatically
 refreshing the context. 
 | 
FileSystemXmlApplicationContext(ApplicationContext parent)
Create a new FileSystemXmlApplicationContext for bean-style configuration. 
 | 
FileSystemXmlApplicationContext(String[] configLocations,
                               ApplicationContext parent)
Create a new FileSystemXmlApplicationContext with the given parent,
 loading the definitions from the given XML files and automatically
 refreshing the context. 
 | 
FileSystemXmlApplicationContext(String[] configLocations,
                               boolean refresh,
                               ApplicationContext parent)
Create a new FileSystemXmlApplicationContext with the given parent,
 loading the definitions from the given XML files. 
 | 
GenericApplicationContext(ApplicationContext parent)
Create a new GenericApplicationContext with the given parent. 
 | 
GenericApplicationContext(DefaultListableBeanFactory beanFactory,
                         ApplicationContext parent)
Create a new GenericApplicationContext with the given DefaultListableBeanFactory. 
 | 
StaticApplicationContext(ApplicationContext parent)
Create a new StaticApplicationContext with the given parent. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Jackson2ObjectMapperBuilder | 
Jackson2ObjectMapperBuilder.applicationContext(ApplicationContext applicationContext)
Set the Spring  
ApplicationContext in order to autowire Jackson handlers (JsonSerializer,
 JsonDeserializer, KeyDeserializer, TypeResolverBuilder and TypeIdResolver). | 
void | 
Jackson2ObjectMapperFactoryBean.setApplicationContext(ApplicationContext applicationContext)
Set the builder  
ApplicationContext in order to autowire Jackson handlers
 (JsonSerializer, JsonDeserializer, KeyDeserializer,
 TypeResolverBuilder and TypeIdResolver). | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
ResourceAdapterApplicationContext
ApplicationContext implementation
 for a JCA ResourceAdapter. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
JmsListenerEndpointRegistry.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
AbstractMethodMessageHandler.getApplicationContext()  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
AbstractMethodMessageHandler.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
AbstractMethodMessageHandler.getApplicationContext()  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
AbstractMethodMessageHandler.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
AbstractMessageBrokerConfiguration.getApplicationContext()  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
AbstractMessageBrokerConfiguration.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ScheduledAnnotationBeanPostProcessor.setApplicationContext(ApplicationContext applicationContext)
Setting an  
ApplicationContext is optional: If set, registered
 tasks will be activated in the ContextRefreshedEvent phase;
 if not set, it will happen at ScheduledAnnotationBeanPostProcessor.afterSingletonsInstantiated() time. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
SpringBeanJobFactory.setApplicationContext(ApplicationContext applicationContext)  | 
void | 
SchedulerFactoryBean.setApplicationContext(ApplicationContext applicationContext)  | 
void | 
JobDetailFactoryBean.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
TestContext.getApplicationContext()
Get the application context for this
 test context, possibly cached. 
 | 
ApplicationContext | 
MergedContextConfiguration.getParentApplicationContext()
Get the parent  
ApplicationContext for the context defined by this
 MergedContextConfiguration from the context cache. | 
ApplicationContext | 
CacheAwareContextLoaderDelegate.loadContext(MergedContextConfiguration mergedContextConfiguration)
Load the application context for the supplied
  
MergedContextConfiguration by delegating to the ContextLoader
 configured in the given MergedContextConfiguration. | 
ApplicationContext | 
SmartContextLoader.loadContext(MergedContextConfiguration mergedConfig)
Loads a new  
context based on the supplied
 merged context configuration,
 configures the context, and finally returns the context in a fully
 refreshed state. | 
ApplicationContext | 
ContextLoader.loadContext(String... locations)
Loads a new  
context based on the supplied
 locations, configures the context, and finally returns
 the context in fully refreshed state. | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
DefaultContextCache.get(MergedContextConfiguration key)
Obtain a cached  
ApplicationContext for the given key. | 
ApplicationContext | 
ContextCache.get(MergedContextConfiguration key)
Obtain a cached  
ApplicationContext for the given key. | 
ApplicationContext | 
DefaultCacheAwareContextLoaderDelegate.loadContext(MergedContextConfiguration mergedContextConfiguration)  | 
protected ApplicationContext | 
DefaultCacheAwareContextLoaderDelegate.loadContextInternal(MergedContextConfiguration mergedContextConfiguration)
Load the  
ApplicationContext for the supplied merged context configuration. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
DefaultContextCache.put(MergedContextConfiguration key,
   ApplicationContext context)
Explicitly add an  
ApplicationContext instance to the cache
 under the given key, potentially honoring a custom eviction policy. | 
void | 
ContextCache.put(MergedContextConfiguration key,
   ApplicationContext context)
Explicitly add an  
ApplicationContext instance to the cache
 under the given key, potentially honoring a custom eviction policy. | 
| Modifier and Type | Method and Description | 
|---|---|
static ApplicationContext | 
SpringExtension.getApplicationContext(ExtensionContext context)
Get the  
ApplicationContext associated with the supplied ExtensionContext. | 
| Modifier and Type | Field and Description | 
|---|---|
protected ApplicationContext | 
AbstractJUnit4SpringContextTests.applicationContext
The  
ApplicationContext that was injected into this test instance
 via AbstractJUnit4SpringContextTests.setApplicationContext(ApplicationContext). | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
AbstractJUnit4SpringContextTests.setApplicationContext(ApplicationContext applicationContext)
Set the  
ApplicationContext to be used by this test instance,
 provided via ApplicationContextAware semantics. | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
DefaultTestContext.getApplicationContext()
Get the application context for this
 test context. 
 | 
ApplicationContext | 
AbstractDelegatingSmartContextLoader.loadContext(MergedContextConfiguration mergedConfig)
Delegates to an appropriate candidate  
SmartContextLoader to load
 an ApplicationContext. | 
ApplicationContext | 
AbstractDelegatingSmartContextLoader.loadContext(String... locations)
AbstractDelegatingSmartContextLoader does not support the
 ContextLoader.loadContext(String...) method. | 
| Modifier and Type | Field and Description | 
|---|---|
protected ApplicationContext | 
AbstractTestNGSpringContextTests.applicationContext
The  
ApplicationContext that was injected into this test instance
 via AbstractTestNGSpringContextTests.setApplicationContext(ApplicationContext). | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
AbstractTestNGSpringContextTests.setApplicationContext(ApplicationContext applicationContext)
Set the  
ApplicationContext to be used by this test instance,
 provided via ApplicationContextAware semantics. | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
AbstractGenericWebContextLoader.loadContext(String... locations)
AbstractGenericWebContextLoader should be used as a
 SmartContextLoader,
 not as a legacy ContextLoader. | 
| Modifier and Type | Method and Description | 
|---|---|
static WebTestClient.MockServerSpec<?> | 
WebTestClient.bindToApplicationContext(ApplicationContext applicationContext)
Use this option to setup a server from the Spring configuration of your
 application, or some subset of it. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static ThemeSource | 
UiApplicationContextUtils.initThemeSource(ApplicationContext context)
Initialize the ThemeSource for the given application context,
 autodetecting a bean with the name "themeSource". 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
LocalValidatorFactoryBean.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
ConfigurableWebApplicationContext
Interface to be implemented by configurable web application contexts. 
 | 
interface  | 
WebApplicationContext
Interface to provide configuration for a web application. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected ApplicationContext | 
ContextLoader.loadParentContext(ServletContext servletContext)
Template method with default implementation (which may be overridden by a
 subclass), to load or obtain an ApplicationContext instance which will be
 used as the parent context of the root WebApplicationContext. 
 | 
| 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 void | 
WebApplicationObjectSupport.initApplicationContext(ApplicationContext context)
Calls  
WebApplicationObjectSupport.initServletContext(javax.servlet.ServletContext) if the
 given ApplicationContext is a WebApplicationContext. | 
| Modifier and Type | Method and Description | 
|---|---|
static List<ControllerAdviceBean> | 
ControllerAdviceBean.findAnnotatedBeans(ApplicationContext context)
Find beans annotated with  
@ControllerAdvice in the
 given ApplicationContext and wrap them as ControllerAdviceBean
 instances. | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
DispatcherHandler.initStrategies(ApplicationContext context)  | 
void | 
DispatcherHandler.setApplicationContext(ApplicationContext applicationContext)  | 
| Constructor and Description | 
|---|
DispatcherHandler(ApplicationContext applicationContext)
Create a new  
DispatcherHandler for the given ApplicationContext. | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
WebFluxConfigurationSupport.getApplicationContext()  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
WebFluxConfigurationSupport.setApplicationContext(ApplicationContext applicationContext)  | 
| Constructor and Description | 
|---|
ViewResolverRegistry(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
RequestMappingHandlerAdapter.setApplicationContext(ApplicationContext applicationContext)
A  
ConfigurableApplicationContext is expected for resolving
 expressions in method argument default values as well as for
 detecting @ControllerAdvice beans. | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
UrlBasedViewResolver.getApplicationContext()
Return the containing  
ApplicationContext, if any. | 
ApplicationContext | 
AbstractView.getApplicationContext()  | 
protected ApplicationContext | 
AbstractView.obtainApplicationContext()
Obtain the  
ApplicationContext for actual use. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
UrlBasedViewResolver.setApplicationContext(ApplicationContext applicationContext)
Accept the containing  
ApplicationContext, if any. | 
void | 
AbstractView.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
RenderingContext.getApplicationContext()
Return the application context. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ScriptTemplateView.setApplicationContext(ApplicationContext context)  | 
| Constructor and Description | 
|---|
RenderingContext(ApplicationContext applicationContext,
                Locale locale,
                Function<String,String> templateLoader,
                String url)
Create a new  
RenderingContext. | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
ServerWebExchange.getApplicationContext()
Return the  
ApplicationContext associated with the web application,
 if it was initialized with one via
 WebHttpHandlerBuilder.applicationContext(ApplicationContext). | 
ApplicationContext | 
ServerWebExchangeDecorator.getApplicationContext()  | 
| Modifier and Type | Method and Description | 
|---|---|
protected ApplicationContext | 
AbstractReactiveWebInitializer.createApplicationContext()
Return the Spring configuration that contains application beans including
 the ones detected by  
WebHttpHandlerBuilder.applicationContext. | 
ApplicationContext | 
DefaultServerWebExchange.getApplicationContext()  | 
ApplicationContext | 
HttpWebHandlerAdapter.getApplicationContext()
Return the configured  
ApplicationContext, if any. | 
| Modifier and Type | Method and Description | 
|---|---|
static WebHttpHandlerBuilder | 
WebHttpHandlerBuilder.applicationContext(ApplicationContext context)
Static factory method to create a new builder instance by detecting beans
 in an  
ApplicationContext. | 
protected void | 
AbstractReactiveWebInitializer.refreshApplicationContext(ApplicationContext context)
Refresh the given application context, if necessary. 
 | 
protected void | 
AbstractReactiveWebInitializer.registerCloseListener(ServletContext servletContext,
                     ApplicationContext applicationContext)
Register a  
ServletContextListener that closes the given
 application context when the servlet context is destroyed. | 
void | 
HttpWebHandlerAdapter.setApplicationContext(ApplicationContext applicationContext)
Configure the  
ApplicationContext associated with the web application,
 if it was initialized with one via
 WebHttpHandlerBuilder.applicationContext(ApplicationContext). | 
| Modifier and Type | Method and Description | 
|---|---|
protected Object | 
DispatcherServlet.createDefaultStrategy(ApplicationContext context,
                     Class<?> clazz)
Create a default strategy. 
 | 
protected WebApplicationContext | 
FrameworkServlet.createWebApplicationContext(ApplicationContext parent)
Instantiate the WebApplicationContext for this servlet, either a default
  
XmlWebApplicationContext
 or a custom context class, if set. | 
protected <T> List<T> | 
DispatcherServlet.getDefaultStrategies(ApplicationContext context,
                    Class<T> strategyInterface)
Create a List of default strategy objects for the given strategy interface. 
 | 
protected <T> T | 
DispatcherServlet.getDefaultStrategy(ApplicationContext context,
                  Class<T> strategyInterface)
Return the default strategy object for the given strategy interface. 
 | 
protected void | 
DispatcherServlet.initStrategies(ApplicationContext context)
Initialize the strategy objects that this servlet uses. 
 | 
protected void | 
FrameworkServlet.onRefresh(ApplicationContext context)
Template method which can be overridden to add servlet-specific refresh work. 
 | 
protected void | 
DispatcherServlet.onRefresh(ApplicationContext context)
This implementation calls  
DispatcherServlet.initStrategies(org.springframework.context.ApplicationContext). | 
void | 
FrameworkServlet.setApplicationContext(ApplicationContext applicationContext)
Called by Spring via  
ApplicationContextAware to inject the current
 application context. | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
WebMvcConfigurationSupport.getApplicationContext()
Return the associated Spring  
ApplicationContext. | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
RedirectViewControllerRegistration.setApplicationContext(ApplicationContext applicationContext)  | 
protected void | 
ViewControllerRegistration.setApplicationContext(ApplicationContext applicationContext)  | 
void | 
WebMvcConfigurationSupport.setApplicationContext(ApplicationContext applicationContext)
Set the Spring  
ApplicationContext, e.g. | 
| Constructor and Description | 
|---|
ResourceHandlerRegistry(ApplicationContext applicationContext,
                       ServletContext servletContext)
Create a new resource handler registry for the given application context. 
 | 
ResourceHandlerRegistry(ApplicationContext applicationContext,
                       ServletContext servletContext,
                       ContentNegotiationManager contentNegotiationManager)
Create a new resource handler registry for the given application context. 
 | 
ResourceHandlerRegistry(ApplicationContext applicationContext,
                       ServletContext servletContext,
                       ContentNegotiationManager contentNegotiationManager,
                       UrlPathHelper pathHelper)
A variant of
  
ResourceHandlerRegistry.ResourceHandlerRegistry(ApplicationContext, ServletContext, ContentNegotiationManager)
 that also accepts the UrlPathHelper used for mapping requests to static resources. | 
ViewControllerRegistry(ApplicationContext applicationContext)
Class constructor with  
ApplicationContext. | 
ViewResolverRegistry(ContentNegotiationManager contentNegotiationManager,
                    ApplicationContext context)
Class constructor with  
ContentNegotiationManager and ApplicationContext. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
HandlerMappingIntrospector.setApplicationContext(ApplicationContext applicationContext)  | 
| Constructor and Description | 
|---|
HandlerMappingIntrospector(ApplicationContext context)
Deprecated. 
 
as of 4.3.12, in favor of  
HandlerMappingIntrospector.setApplicationContext(org.springframework.context.ApplicationContext) | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
ExceptionHandlerExceptionResolver.getApplicationContext()  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ExceptionHandlerExceptionResolver.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
ResourceUrlProvider.detectResourceHandlers(ApplicationContext appContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
ViewResolverComposite.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
protected ApplicationContext | 
GroovyMarkupConfigurer.getApplicationContext()  | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
GroovyMarkupView.initApplicationContext(ApplicationContext context)
Invoked at startup. 
 | 
void | 
GroovyMarkupConfigurer.setApplicationContext(ApplicationContext applicationContext)  | 
| Modifier and Type | Method and Description | 
|---|---|
ApplicationContext | 
RenderingContext.getApplicationContext()
Return the application context. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
ScriptTemplateView.initApplicationContext(ApplicationContext context)  | 
| Constructor and Description | 
|---|
RenderingContext(ApplicationContext applicationContext,
                Locale locale,
                Function<String,String> templateLoader,
                String url)
Create a new  
RenderingContext. | 
| Modifier and Type | Method and Description | 
|---|---|
protected ApplicationContext | 
ConvertingEncoderDecoderSupport.getApplicationContext()
Returns the active  
ApplicationContext. | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
WebMvcStompEndpointRegistry.setApplicationContext(ApplicationContext applicationContext)  |