## Uses of Interface
org.springframework.context.ApplicationContextAware

- Packages that use ApplicationContextAware
  Package | Description
  --- | ---
  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.jms.config | Support package for declarative messaging configuration, with Java configuration and XML schema support.
  org.springframework.messaging.handler.annotation.reactive | Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
  org.springframework.messaging.handler.invocation | Common infrastructure for invoking message handler methods.
  org.springframework.messaging.rsocket.annotation.support | Support classes for working with annotated RSocket stream handling methods.
  org.springframework.messaging.simp.annotation.support | Support classes for handling messages from simple messaging protocols (like STOMP).
  org.springframework.messaging.simp.config | Configuration support for WebSocket messaging using higher level messaging protocols.
  org.springframework.scheduling.annotation | Annotation support 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.junit4 | Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.
  org.springframework.test.context.testng | Support classes for integrating the Spring TestContext Framework with TestNG.
  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.support | Classes supporting the `org.springframework.web.context` package, such as WebApplicationContext implementations and various utility classes.
  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.function.server.support | Classes supporting the `org.springframework.web.reactive.function.server` package.
  org.springframework.web.reactive.handler | Provides HandlerMapping implementations including abstract base classes.
  org.springframework.web.reactive.resource | Support classes for serving static resources.
  org.springframework.web.reactive.result.method | Infrastructure for handler method processing.
  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.freemarker | Support classes for the integration of FreeMarker as Spring web view technology.
  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.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 | Standard controller implementations for the Servlet MVC framework that comes with Spring.
  org.springframework.web.servlet.mvc.method | Servlet-based infrastructure for handler method processing, building on the `org.springframework.web.method` package.
  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.support | Support classes for Spring's web MVC framework.
  org.springframework.web.servlet.view | Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
  org.springframework.web.servlet.view.document | Support classes for document generation, providing View implementations for PDF and Excel.
  org.springframework.web.servlet.view.feed | Support classes for feed generation, providing View implementations for Atom and RSS.
  org.springframework.web.servlet.view.groovy | Support classes for the integration of Groovy Templates as Spring web view technology.
  org.springframework.web.servlet.view.json | Support classes for providing a View implementation based on JSON serialization.
  org.springframework.web.servlet.view.tiles3 | Support classes for the integration of Tiles 3 (the standalone version of Tiles) as Spring web view technology.
  org.springframework.web.servlet.view.xml | Support classes for providing a View implementation based on XML Marshalling.
  org.springframework.web.servlet.view.xslt | Support classes for XSLT, providing a View implementation for XSLT stylesheets.
  org.springframework.web.socket.config.annotation | Support for annotation-based WebSocket setup in configuration classes.
  org.springframework.web.socket.messaging | WebSocket integration for Spring's messaging module.
  org.springframework.web.socket.server.standard | Server-side classes for use with standard JSR-356 WebSocket endpoints.
  org.springframework.web.socket.server.support | Server-side support classes including container-specific strategies for upgrading a request.

- - ### Uses of ApplicationContextAware in org.springframework.context.event

    Classes in org.springframework.context.event that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `EventListenerMethodProcessor` Registers `EventListener` methods as individual `ApplicationListener` instances.

  - ### Uses of ApplicationContextAware in org.springframework.context.support

    Classes in org.springframework.context.support that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ApplicationObjectSupport` Convenient superclass for application objects that want to be aware of the application context, e.g.
    `class` | `LiveBeansView` Deprecated. as of 5.3, in favor of using Spring Boot actuators for such needs

  - ### Uses of ApplicationContextAware in org.springframework.http.converter.json

    Classes in org.springframework.http.converter.json that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Jackson2ObjectMapperFactoryBean` A `FactoryBean` for creating a Jackson 2.x `ObjectMapper` (default) or `XmlMapper` (`createXmlMapper` property set to true) with setters to enable or disable Jackson features from within XML configuration.

  - ### Uses of ApplicationContextAware in org.springframework.jms.config

    Classes in org.springframework.jms.config that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JmsListenerEndpointRegistry` Creates the necessary `MessageListenerContainer` instances for the registered endpoints.

  - ### Uses of ApplicationContextAware in org.springframework.messaging.handler.annotation.reactive

    Classes in org.springframework.messaging.handler.annotation.reactive that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MessageMappingMessageHandler` Extension of `AbstractMethodMessageHandler` for reactive, non-blocking handling of messages via `@MessageMapping` methods.

  - ### Uses of ApplicationContextAware in org.springframework.messaging.handler.invocation

    Classes in org.springframework.messaging.handler.invocation that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractMethodMessageHandler<T>` Abstract base class for HandlerMethod-based message handling.

  - ### Uses of ApplicationContextAware in org.springframework.messaging.rsocket.annotation.support

    Classes in org.springframework.messaging.rsocket.annotation.support that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `RSocketMessageHandler` Extension of `MessageMappingMessageHandler` for handling RSocket requests with `@ConnectMapping` and `@MessageMapping` methods.

  - ### Uses of ApplicationContextAware in org.springframework.messaging.simp.annotation.support

    Classes in org.springframework.messaging.simp.annotation.support that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SimpAnnotationMethodMessageHandler` A handler for messages delegating to `@MessageMapping` and `@SubscribeMapping` annotated methods.

  - ### Uses of ApplicationContextAware in org.springframework.messaging.simp.config

    Classes in org.springframework.messaging.simp.config that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractMessageBrokerConfiguration` Provides essential configuration for handling messages with simple messaging protocols such as STOMP.

  - ### Uses of ApplicationContextAware in org.springframework.scheduling.annotation

    Classes in org.springframework.scheduling.annotation that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ScheduledAnnotationBeanPostProcessor` Bean post-processor that registers methods annotated with `@Scheduled` to be invoked by a `TaskScheduler` according to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation.

  - ### Uses of ApplicationContextAware in org.springframework.scheduling.quartz

    Classes in org.springframework.scheduling.quartz that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JobDetailFactoryBean` A Spring `FactoryBean` for creating a Quartz `JobDetail` instance, supporting bean-style usage for JobDetail configuration.
    `class` | `SchedulerFactoryBean` `FactoryBean` that creates and configures a Quartz `Scheduler`, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.
    `class` | `SpringBeanJobFactory` Subclass of `AdaptableJobFactory` that also supports Spring-style dependency injection on bean properties.

  - ### Uses of ApplicationContextAware in org.springframework.test.context.junit4

    Classes in org.springframework.test.context.junit4 that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractJUnit4SpringContextTests` Abstract base test class which integrates the Spring TestContext Framework with explicit `ApplicationContext` testing support in a JUnit 4 environment.
    `class` | `AbstractTransactionalJUnit4SpringContextTests` Abstract transactional extension of `AbstractJUnit4SpringContextTests` which adds convenience functionality for JDBC access.

  - ### Uses of ApplicationContextAware in org.springframework.test.context.testng

    Classes in org.springframework.test.context.testng that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractTestNGSpringContextTests` Abstract base test class which integrates the Spring TestContext Framework with explicit `ApplicationContext` testing support in a TestNG environment.
    `class` | `AbstractTransactionalTestNGSpringContextTests` Abstract transactional extension of `AbstractTestNGSpringContextTests` which adds convenience functionality for JDBC access.

  - ### Uses of ApplicationContextAware in org.springframework.validation.beanvalidation

    Classes in org.springframework.validation.beanvalidation that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `LocalValidatorFactoryBean` This is the central class for `javax.validation` (JSR-303) setup in a Spring application context: It bootstraps a `javax.validation.ValidationFactory` and exposes it through the Spring `Validator` interface as well as through the JSR-303 `Validator` interface and the `ValidatorFactory` interface itself.
    `class` | `OptionalValidatorFactoryBean` `LocalValidatorFactoryBean` subclass that simply turns `Validator` calls into no-ops in case of no Bean Validation provider being available.

  - ### Uses of ApplicationContextAware in org.springframework.web.context.support

    Classes in org.springframework.web.context.support that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ServletContextLiveBeansView` Deprecated. as of 5.3, in favor of using Spring Boot actuators for such needs
    `class` | `WebApplicationObjectSupport` Convenient superclass for application objects running in a `WebApplicationContext`.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive

    Classes in org.springframework.web.reactive that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DispatcherHandler` Central dispatcher for HTTP request handlers/controllers.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive.config

    Classes in org.springframework.web.reactive.config that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DelegatingWebFluxConfiguration` A subclass of `WebFluxConfigurationSupport` that detects and delegates to all beans of type `WebFluxConfigurer` allowing them to customize the configuration provided by `WebFluxConfigurationSupport`.
    `class` | `WebFluxConfigurationSupport` The main class for Spring WebFlux configuration.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive.function.server.support

    Classes in org.springframework.web.reactive.function.server.support that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `RouterFunctionMapping` `HandlerMapping` implementation that supports `RouterFunctions`.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive.handler

    Classes in org.springframework.web.reactive.handler that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractHandlerMapping` Abstract base class for `HandlerMapping` implementations.
    `class` | `AbstractUrlHandlerMapping` Abstract base class for URL-mapped `HandlerMapping` implementations.
    `class` | `SimpleUrlHandlerMapping` Implementation of the `HandlerMapping` interface to map from URLs to request handler beans.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive.resource

    Classes in org.springframework.web.reactive.resource that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ResourceUrlProvider` A central component to use to obtain the public URL path that clients should use to access a static resource.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive.result.method

    Classes in org.springframework.web.reactive.result.method that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractHandlerMethodMapping<T>` Abstract base class for `HandlerMapping` implementations that define a mapping between a request and a `HandlerMethod`.
    `class` | `RequestMappingInfoHandlerMapping` Abstract base class for classes for which `RequestMappingInfo` defines the mapping between a request and a handler method.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive.result.method.annotation

    Classes in org.springframework.web.reactive.result.method.annotation that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `RequestMappingHandlerAdapter` Supports the invocation of `@RequestMapping` handler methods.
    `class` | `RequestMappingHandlerMapping` An extension of `RequestMappingInfoHandlerMapping` that creates `RequestMappingInfo` instances from class-level and method-level `@RequestMapping` annotations.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive.result.view

    Classes in org.springframework.web.reactive.result.view that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractUrlBasedView` Abstract base class for URL-based views.
    `class` | `AbstractView` Base class for `View` implementations.
    `class` | `RedirectView` View that redirects to an absolute or context relative URL.
    `class` | `UrlBasedViewResolver` A `ViewResolver` that allows direct resolution of symbolic view names to URLs without explicit mapping definitions.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive.result.view.freemarker

    Classes in org.springframework.web.reactive.result.view.freemarker that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `FreeMarkerView` A `View` implementation that uses the FreeMarker template engine.
    `class` | `FreeMarkerViewResolver` A `ViewResolver` for resolving `FreeMarkerView` instances, i.e.

  - ### Uses of ApplicationContextAware in org.springframework.web.reactive.result.view.script

    Classes in org.springframework.web.reactive.result.view.script that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ScriptTemplateView` An `AbstractUrlBasedView` subclass designed to run any template library based on a JSR-223 script engine.
    `class` | `ScriptTemplateViewResolver` Convenience subclass of `UrlBasedViewResolver` that supports `ScriptTemplateView` and custom subclasses of it.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet

    Classes in org.springframework.web.servlet that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DispatcherServlet` Central dispatcher for HTTP request handlers/controllers, e.g.
    `class` | `FrameworkServlet` Base servlet for Spring's web framework.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.config.annotation

    Classes in org.springframework.web.servlet.config.annotation that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DelegatingWebMvcConfiguration` A subclass of `WebMvcConfigurationSupport` that detects and delegates to all beans of type `WebMvcConfigurer` allowing them to customize the configuration provided by `WebMvcConfigurationSupport`.
    `class` | `WebMvcConfigurationSupport` This is the main class providing the configuration behind the MVC Java config.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.handler

    Classes in org.springframework.web.servlet.handler that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractDetectingUrlHandlerMapping` Abstract implementation of the `HandlerMapping` interface, detecting URL mappings for handler beans through introspection of all defined beans in the application context.
    `class` | `BeanNameUrlHandlerMapping` Implementation of the `HandlerMapping` interface that maps from URLs to beans with names that start with a slash ("/"), similar to how Struts maps URLs to action names.
    `class` | `HandlerMappingIntrospector` Helper class to get information from the `HandlerMapping` that would serve a specific request.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.mvc

    Classes in org.springframework.web.servlet.mvc that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractController` Convenient superclass for controller implementations, using the Template Method design pattern.
    `class` | `AbstractUrlViewController` Abstract base class for `Controllers` that return a view name based on the request URL.
    `class` | `ParameterizableViewController` Trivial controller that always returns a pre-configured view and optionally sets the response status code.
    `class` | `ServletForwardingController` Spring Controller implementation that forwards to a named servlet, i.e.
    `class` | `ServletWrappingController` Spring Controller implementation that wraps a servlet instance which it manages internally.
    `class` | `UrlFilenameViewController` Simple `Controller` implementation that transforms the virtual path of a URL into a view name and returns that view.
    `class` | `WebContentInterceptor` Handler interceptor that checks the request for supported methods and a required session and prepares the response by applying the configured cache settings.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.mvc.method

    Classes in org.springframework.web.servlet.mvc.method that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractHandlerMethodAdapter` Abstract base class for `HandlerAdapter` implementations that support handlers of type `HandlerMethod`.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.mvc.method.annotation

    Classes in org.springframework.web.servlet.mvc.method.annotation that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ExceptionHandlerExceptionResolver` An `AbstractHandlerMethodExceptionResolver` that resolves exceptions through `@ExceptionHandler` methods.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.resource

    Classes in org.springframework.web.servlet.resource that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ResourceHttpRequestHandler` `HttpRequestHandler` that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.support

    Classes in org.springframework.web.servlet.support that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `WebContentGenerator` Convenient superclass for any kind of web content generator, like `AbstractController` and `WebContentInterceptor`.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.view

    Classes in org.springframework.web.servlet.view that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractCachingViewResolver` Convenient base class for `ViewResolver` implementations.
    `class` | `AbstractTemplateView` Adapter base class for template-based view technologies such as FreeMarker, with the ability to use request and session attributes in their model and the option to expose helper objects for Spring's FreeMarker macro library.
    `class` | `AbstractTemplateViewResolver` Abstract base class for template view resolvers, in particular for FreeMarker views.
    `class` | `BeanNameViewResolver` A simple implementation of `ViewResolver` that interprets a view name as a bean name in the current application context, i.e.
    `class` | `ContentNegotiatingViewResolver` Implementation of `ViewResolver` that resolves a view based on the request file name or `Accept` header.
    `class` | `InternalResourceView` Wrapper for a JSP or other resource within the same web application.
    `class` | `InternalResourceViewResolver` Convenient subclass of `UrlBasedViewResolver` that supports `InternalResourceView` (i.e.
    `class` | `JstlView` Specialization of `InternalResourceView` for JSTL pages, i.e.
    `class` | `ResourceBundleViewResolver` Deprecated. as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementations
    `class` | `ViewResolverComposite` A `ViewResolver` that delegates to others.
    `class` | `XmlViewResolver` Deprecated. as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementations

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.view.document

    Classes in org.springframework.web.servlet.view.document that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractPdfStamperView` Abstract superclass for PDF views that operate on an existing document with an AcroForm.
    `class` | `AbstractPdfView` Abstract superclass for PDF views.
    `class` | `AbstractXlsView` Convenient superclass for Excel document views in traditional XLS format.
    `class` | `AbstractXlsxStreamingView` Convenient superclass for Excel document views in the Office 2007 XLSX format, using POI's streaming variant.
    `class` | `AbstractXlsxView` Convenient superclass for Excel document views in the Office 2007 XLSX format (as supported by POI-OOXML).

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.view.feed

    Classes in org.springframework.web.servlet.view.feed that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractAtomFeedView` Abstract superclass for Atom Feed views, using the ROME package.
    `class` | `AbstractFeedView<T extends com.rometools.rome.feed.WireFeed>` Abstract base class for Atom and RSS Feed views, using the ROME package.
    `class` | `AbstractRssFeedView` Abstract superclass for RSS Feed views, using the ROME package.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.view.groovy

    Classes in org.springframework.web.servlet.view.groovy that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `GroovyMarkupConfigurer` An extension of Groovy's `TemplateConfiguration` and an implementation of Spring MVC's `GroovyMarkupConfig` for creating a `MarkupTemplateEngine` for use in a web application.
    `class` | `GroovyMarkupView` An `AbstractTemplateView` subclass based on Groovy XML/XHTML markup templates.
    `class` | `GroovyMarkupViewResolver` Convenience subclass of `AbstractTemplateViewResolver` that supports `GroovyMarkupView` (i.e.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.view.json

    Classes in org.springframework.web.servlet.view.json that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractJackson2View` Abstract base class for Jackson based and content type independent `AbstractView` implementations.
    `class` | `MappingJackson2JsonView` Spring MVC `View` that renders JSON content by serializing the model for the current request using Jackson 2's `ObjectMapper`.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.view.tiles3

    Classes in org.springframework.web.servlet.view.tiles3 that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `TilesView` `View` implementation that renders through the Tiles Request API.
    `class` | `TilesViewResolver` Convenience subclass of `UrlBasedViewResolver` that supports `TilesView` (i.e.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.view.xml

    Classes in org.springframework.web.servlet.view.xml that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MappingJackson2XmlView` Spring MVC `View` that renders XML content by serializing the model for the current request using Jackson 2's `XmlMapper`.
    `class` | `MarshallingView` Spring-MVC `View` that allows for response context to be rendered as the result of marshalling by a `Marshaller`.

  - ### Uses of ApplicationContextAware in org.springframework.web.servlet.view.xslt

    Classes in org.springframework.web.servlet.view.xslt that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `XsltView` XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation.
    `class` | `XsltViewResolver` `ViewResolver` implementation that resolves instances of `XsltView` by translating the supplied view name into the URL of the XSLT stylesheet.

  - ### Uses of ApplicationContextAware in org.springframework.web.socket.config.annotation

    Classes in org.springframework.web.socket.config.annotation that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DelegatingWebSocketMessageBrokerConfiguration` A `WebSocketMessageBrokerConfigurationSupport` extension that detects beans of type `WebSocketMessageBrokerConfigurer` and delegates to all of them allowing callback style customization of the configuration provided in `WebSocketMessageBrokerConfigurationSupport`.
    `class` | `WebSocketMessageBrokerConfigurationSupport` Extends `AbstractMessageBrokerConfiguration` and adds configuration for receiving and responding to STOMP messages from WebSocket clients.

  - ### Uses of ApplicationContextAware in org.springframework.web.socket.messaging

    Classes in org.springframework.web.socket.messaging that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `WebSocketAnnotationMethodMessageHandler` A subclass of `SimpAnnotationMethodMessageHandler` to provide support for `ControllerAdvice` with global `@MessageExceptionHandler` methods.

  - ### Uses of ApplicationContextAware in org.springframework.web.socket.server.standard

    Classes in org.springframework.web.socket.server.standard that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ServerEndpointExporter` Detects beans of type `ServerEndpointConfig` and registers with the standard Java WebSocket runtime.

  - ### Uses of ApplicationContextAware in org.springframework.web.socket.server.support

    Classes in org.springframework.web.socket.server.support that implement ApplicationContextAware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `WebSocketHandlerMapping` Extension of `SimpleUrlHandlerMapping` with support for more precise mapping of WebSocket handshake requests to handlers of type `WebSocketHttpRequestHandler`.