## Uses of Interface
org.springframework.beans.factory.Aware

- Packages that use Aware
  Package | Description
  --- | ---
  org.springframework.aop.aspectj | AspectJ integration package.
  org.springframework.aop.aspectj.annotation | Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
  org.springframework.aop.aspectj.autoproxy | Base classes enabling auto-proxying based on AspectJ.
  org.springframework.aop.config | Support package for declarative AOP configuration, with XML schema being the primary configuration format.
  org.springframework.aop.framework | Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
  org.springframework.aop.framework.autoproxy | Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
  org.springframework.aop.framework.autoproxy.target | Various `TargetSourceCreator` implementations for use with Spring's AOP auto-proxying support.
  org.springframework.aop.interceptor | Provides miscellaneous interceptor implementations.
  org.springframework.aop.scope | Support for AOP-based scoping of target objects, with configurable backend.
  org.springframework.aop.support | Convenience classes for using Spring's AOP API.
  org.springframework.aop.target |
  org.springframework.beans.factory | The core package implementing Spring's lightweight Inversion of Control (IoC) container.
  org.springframework.beans.factory.annotation | Support package for annotation-driven bean configuration.
  org.springframework.beans.factory.config | SPI interfaces and configuration-related convenience classes for bean factories.
  org.springframework.beans.factory.serviceloader | Support package for the Java `ServiceLoader` facility.
  org.springframework.beans.factory.support | Classes supporting the `org.springframework.beans.factory` package.
  org.springframework.beans.factory.wiring | Mechanism to determine bean wiring metadata from a bean instance.
  org.springframework.cache.annotation | Annotations and supporting classes for declarative cache management.
  org.springframework.cache.aspectj |
  org.springframework.cache.concurrent | Implementation package for `java.util.concurrent` based caches.
  org.springframework.cache.ehcache | Support classes for the open source cache EhCache 2.x, allowing to set up an EhCache CacheManager and Caches as beans in a Spring context.
  org.springframework.cache.interceptor | AOP-based solution for declarative caching demarcation.
  org.springframework.cache.jcache | Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
  org.springframework.cache.jcache.config | Support package for declarative JSR-107 caching configuration.
  org.springframework.cache.jcache.interceptor | AOP-based solution for declarative caching demarcation using JSR-107 annotations.
  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.context.weaving | Load-time weaving support for a Spring application context, building on Spring's `LoadTimeWeaver` abstraction.
  org.springframework.dao.annotation | Annotation support for DAOs.
  org.springframework.dao.support | Support classes for DAO implementations, providing miscellaneous utility methods.
  org.springframework.ejb.access | This package contains classes that allow easy access to EJBs.
  org.springframework.format.datetime | Formatters for `java.util.Date` properties.
  org.springframework.format.datetime.joda | Integration with Joda-Time for formatting Joda date and time types as well as standard JDK Date types.
  org.springframework.format.datetime.standard | Integration with the JSR-310 `java.time` package in JDK 8.
  org.springframework.format.number | Formatters for `java.lang.Number` properties.
  org.springframework.format.number.money | Integration with the JSR-354 `javax.money` package.
  org.springframework.format.support | Support classes for the formatting package, providing common implementations as well as adapters.
  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.jca.endpoint | This package provides a facility for generic JCA message endpoint management.
  org.springframework.jca.work | Convenience classes for scheduling based on the JCA WorkManager facility, as supported within ResourceAdapters.
  org.springframework.jdbc.config | Defines the Spring JDBC configuration namespace.
  org.springframework.jdbc.datasource.lookup | Provides a strategy for looking up JDBC DataSources by name.
  org.springframework.jms.annotation | Annotations and support classes for declarative JMS listener endpoints.
  org.springframework.jms.config | Support package for declarative messaging configuration, with Java configuration and XML schema support.
  org.springframework.jms.listener | This package contains the base message listener container facility.
  org.springframework.jms.listener.endpoint | This package provides JCA-based endpoint management for JMS message listeners.
  org.springframework.jms.remoting | Remoting classes for transparent Java-to-Java remoting via a JMS provider.
  org.springframework.jms.support.converter | Provides a MessageConverter abstraction to convert between Java objects and JMS messages.
  org.springframework.jms.support.destination | Support classes for Spring's JMS framework.
  org.springframework.jmx.access | Provides support for accessing remote MBean resources.
  org.springframework.jmx.export | This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
  org.springframework.jmx.export.annotation | Annotations for MBean exposure.
  org.springframework.jmx.export.assembler | Provides a strategy for MBeanInfo assembly.
  org.springframework.jmx.export.notification | Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
  org.springframework.jmx.support | Contains support classes for connecting to local and remote `MBeanServer`s and for exposing an `MBeanServer` to remote clients.
  org.springframework.jndi | The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes.
  org.springframework.messaging.core | Defines interfaces and implementation classes for messaging templates.
  org.springframework.messaging.handler.annotation.reactive | Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
  org.springframework.messaging.handler.annotation.support | Support classes for working with annotated message-handling methods.
  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.broker | Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
  org.springframework.messaging.simp.config | Configuration support for WebSocket messaging using higher level messaging protocols.
  org.springframework.messaging.simp.stomp | Generic support for simple messaging protocols (like STOMP).
  org.springframework.messaging.support | Provides implementations of `Message` along with a MessageBuilder and MessageHeaderAccessor for building and working with messages and message headers, as well as various `MessageChannel` implementations and channel interceptor support.
  org.springframework.orm.hibernate5 | Package providing integration of Hibernate 5.x with Spring concepts.
  org.springframework.orm.hibernate5.support | Classes supporting the `org.springframework.orm.hibernate5` package.
  org.springframework.orm.jpa | Package providing integration of JPA (Java Persistence API) with Spring concepts.
  org.springframework.orm.jpa.persistenceunit | Internal support for managing JPA persistence units.
  org.springframework.orm.jpa.support | Classes supporting the `org.springframework.orm.jpa` package.
  org.springframework.orm.jpa.vendor | Support classes for adapting to specific JPA vendors.
  org.springframework.oxm.jaxb | Package providing integration of JAXB with Spring's O/X Mapping support.
  org.springframework.oxm.xstream | Package providing integration of XStream with Spring's O/X Mapping support.
  org.springframework.r2dbc.connection.lookup | Provides a strategy for looking up R2DBC ConnectionFactories by name.
  org.springframework.remoting.caucho | This package provides remoting classes for Caucho's Hessian protocol: a proxy factory for accessing Hessian services, and an exporter for making beans available to Hessian clients.
  org.springframework.remoting.httpinvoker | Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
  org.springframework.remoting.jaxws | Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC), as included in Java 6 and Java EE 5.
  org.springframework.remoting.rmi | Remoting classes for conventional RMI and transparent remoting via RMI invokers.
  org.springframework.remoting.support | Generic support classes for remoting implementations.
  org.springframework.scheduling.annotation | Annotation support for asynchronous method execution.
  org.springframework.scheduling.aspectj |
  org.springframework.scheduling.concurrent | Scheduling convenience classes for the `java.util.concurrent` and `javax.enterprise.concurrent` packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
  org.springframework.scheduling.config | Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
  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.scheduling.support | Generic support classes for scheduling.
  org.springframework.scripting.bsh | Package providing integration of BeanShell (and BeanShell2) into Spring's scripting infrastructure.
  org.springframework.scripting.groovy | Package providing integration of Groovy into Spring's scripting infrastructure.
  org.springframework.scripting.support | Support classes for Spring's scripting package.
  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.transaction.annotation | Spring's support for annotation-based transaction demarcation.
  org.springframework.transaction.aspectj |
  org.springframework.transaction.interceptor | AOP-based solution for declarative transaction demarcation.
  org.springframework.ui.context.support | Classes supporting the org.springframework.ui.context package.
  org.springframework.ui.freemarker | Support classes for setting up FreeMarker within a Spring application context.
  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.accept | This package contains classes used to determine the requested the media types in a request.
  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.request.async | Support for asynchronous request processing.
  org.springframework.web.context.support | Classes supporting the `org.springframework.web.context` package, such as WebApplicationContext implementations and various utility classes.
  org.springframework.web.filter | Provides generic filter base classes allowing for bean-style configuration.
  org.springframework.web.multipart.commons | MultipartResolver implementation for Apache Commons FileUpload.
  org.springframework.web.multipart.support | Support classes for the multipart resolution framework.
  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.annotation | Support package for annotation-based Servlet MVC controllers.
  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.client.standard | Client-side classes for use with standard Java WebSocket endpoints.
  org.springframework.web.socket.config.annotation | Support for annotation-based WebSocket setup in configuration classes.
  org.springframework.web.socket.handler | Convenient `WebSocketHandler` implementations and decorators.
  org.springframework.web.socket.messaging | WebSocket integration for Spring's messaging module.
  org.springframework.web.socket.server.jetty | Server-side support for the Jetty 9+ WebSocket API.
  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.
  org.springframework.web.socket.sockjs.support | Support classes for SockJS including an `AbstractSockJsService` implementation.
  org.springframework.web.socket.sockjs.transport.handler | `TransportHandler` implementation classes as well as a concrete `SockJsService`.

- - ### Uses of Aware in org.springframework.aop.aspectj

    Classes in org.springframework.aop.aspectj that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AspectJExpressionPointcut` Spring `Pointcut` implementation that uses the AspectJ weaver to evaluate a pointcut expression.
    `class` | `AspectJExpressionPointcutAdvisor` Spring AOP Advisor that can be used for any AspectJ pointcut expression.

  - ### Uses of Aware in org.springframework.aop.aspectj.annotation

    Classes in org.springframework.aop.aspectj.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AnnotationAwareAspectJAutoProxyCreator` `AspectJAwareAdvisorAutoProxyCreator` subclass that processes all AspectJ annotation aspects in the current application context, as well as Spring Advisors.

  - ### Uses of Aware in org.springframework.aop.aspectj.autoproxy

    Classes in org.springframework.aop.aspectj.autoproxy that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AspectJAwareAdvisorAutoProxyCreator` `AbstractAdvisorAutoProxyCreator` subclass that exposes AspectJ's invocation context and understands AspectJ's rules for advice precedence when multiple pieces of advice come from the same aspect.

  - ### Uses of Aware in org.springframework.aop.config

    Classes in org.springframework.aop.config that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MethodLocatingFactoryBean` `FactoryBean` implementation that locates a `Method` on a specified bean.
    `class` | `SimpleBeanFactoryAwareAspectInstanceFactory` Implementation of `AspectInstanceFactory` that locates the aspect from the `BeanFactory` using a configured bean name.

  - ### Uses of Aware in org.springframework.aop.framework

    Classes in org.springframework.aop.framework that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractAdvisingBeanPostProcessor` Base class for `BeanPostProcessor` implementations that apply a Spring AOP `Advisor` to specific beans.
    `class` | `AbstractSingletonProxyFactoryBean` Convenient superclass for `FactoryBean` types that produce singleton-scoped proxy objects.
    `class` | `ProxyFactoryBean` `FactoryBean` implementation that builds an AOP proxy based on beans in a Spring `BeanFactory`.
    `class` | `ProxyProcessorSupport` Base class with common functionality for proxy processors, in particular ClassLoader management and the `ProxyProcessorSupport.evaluateProxyInterfaces(java.lang.Class<?>, org.springframework.aop.framework.ProxyFactory)` algorithm.

  - ### Uses of Aware in org.springframework.aop.framework.autoproxy

    Classes in org.springframework.aop.framework.autoproxy that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractAdvisorAutoProxyCreator` Generic auto proxy creator that builds AOP proxies for specific beans based on detected Advisors for each bean.
    `class` | `AbstractAutoProxyCreator` `BeanPostProcessor` implementation that wraps each eligible bean with an AOP proxy, delegating to specified interceptors before invoking the bean itself.
    `class` | `AbstractBeanFactoryAwareAdvisingPostProcessor` Extension of `AbstractAutoProxyCreator` which implements `BeanFactoryAware`, adds exposure of the original target class for each proxied bean (`AutoProxyUtils.ORIGINAL_TARGET_CLASS_ATTRIBUTE`), and participates in an externally enforced target-class mode for any given bean (`AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE`).
    `class` | `BeanNameAutoProxyCreator` Auto proxy creator that identifies beans to proxy via a list of names.
    `class` | `DefaultAdvisorAutoProxyCreator` `BeanPostProcessor` implementation that creates AOP proxies based on all candidate `Advisor`s in the current `BeanFactory`.
    `class` | `InfrastructureAdvisorAutoProxyCreator` Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors.

  - ### Uses of Aware in org.springframework.aop.framework.autoproxy.target

    Classes in org.springframework.aop.framework.autoproxy.target that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractBeanFactoryBasedTargetSourceCreator` Convenient superclass for `TargetSourceCreator` implementations that require creating multiple instances of a prototype bean.
    `class` | `LazyInitTargetSourceCreator` `TargetSourceCreator` that enforces a `LazyInitTargetSource` for each bean that is defined as "lazy-init".
    `class` | `QuickTargetSourceCreator` Convenient TargetSourceCreator using bean name prefixes to create one of three well-known TargetSource types: : CommonsPool2TargetSource % ThreadLocalTargetSource ! PrototypeTargetSource

  - ### Uses of Aware in org.springframework.aop.interceptor

    Classes in org.springframework.aop.interceptor that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AsyncExecutionAspectSupport` Base class for asynchronous method execution aspects, such as `org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor` or `org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect`.
    `class` | `AsyncExecutionInterceptor` AOP Alliance `MethodInterceptor` that processes method invocations asynchronously, using a given `AsyncTaskExecutor`.

  - ### Uses of Aware in org.springframework.aop.scope

    Classes in org.springframework.aop.scope that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ScopedProxyFactoryBean` Convenient proxy factory bean for scoped objects.

  - ### Uses of Aware in org.springframework.aop.support

    Classes in org.springframework.aop.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractBeanFactoryPointcutAdvisor` Abstract BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in a BeanFactory.
    `class` | `DefaultBeanFactoryPointcutAdvisor` Concrete BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in the BeanFactory, as well as the Pointcut to be configured through a bean property.

  - ### Uses of Aware in org.springframework.aop.target

    Classes in org.springframework.aop.target that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractBeanFactoryBasedTargetSource` Base class for `TargetSource` implementations that are based on a Spring `BeanFactory`, delegating to Spring-managed bean instances.
    `class` | `AbstractPoolingTargetSource` Abstract base class for pooling `TargetSource` implementations which maintain a pool of target instances, acquiring and releasing a target object from the pool for each method invocation.
    `class` | `AbstractPrototypeBasedTargetSource` Base class for dynamic `TargetSource` implementations that create new prototype bean instances to support a pooling or new-instance-per-invocation strategy.
    `class` | `CommonsPool2TargetSource` `TargetSource` implementation that holds objects in a configurable Apache Commons2 Pool.
    `class` | `LazyInitTargetSource` `TargetSource` that lazily accesses a singleton bean from a `BeanFactory`.
    `class` | `PrototypeTargetSource` `TargetSource` implementation that creates a new instance of the target bean for each request, destroying each instance on release (after each request).
    `class` | `SimpleBeanTargetSource` Simple `TargetSource` implementation, freshly obtaining the specified target bean from its containing Spring `BeanFactory`.
    `class` | `ThreadLocalTargetSource` Alternative to an object pool.

  - ### Uses of Aware in org.springframework.beans.factory

    Subinterfaces of Aware in org.springframework.beans.factory
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BeanClassLoaderAware` Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
    `interface` | `BeanFactoryAware` Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
    `interface` | `BeanNameAware` Interface to be implemented by beans that want to be aware of their bean name in a bean factory.

  - ### Uses of Aware in org.springframework.beans.factory.annotation

    Classes in org.springframework.beans.factory.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AutowiredAnnotationBeanPostProcessor` `BeanPostProcessor` implementation that autowires annotated fields, setter methods, and arbitrary config methods.
    `class` | `CustomAutowireConfigurer` A `BeanFactoryPostProcessor` implementation that allows for convenient registration of custom autowire qualifier types.
    `class` | `QualifierAnnotationAutowireCandidateResolver` `AutowireCandidateResolver` implementation that matches bean definition qualifiers against `qualifier annotations` on the field or parameter to be autowired.
    `class` | `RequiredAnnotationBeanPostProcessor` Deprecated. as of 5.1, in favor of using constructor injection for required settings (or a custom `InitializingBean` implementation)

  - ### Uses of Aware in org.springframework.beans.factory.config

    Classes in org.springframework.beans.factory.config that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractFactoryBean<T>` Simple template superclass for `FactoryBean` implementations that creates a singleton or a prototype object, depending on a flag.
    `class` | `CustomScopeConfigurer` Simple `BeanFactoryPostProcessor` implementation that registers custom `Scope(s)` with the containing `ConfigurableBeanFactory`.
    `class` | `FieldRetrievingFactoryBean` `FactoryBean` which retrieves a static or non-static field value.
    `class` | `ListFactoryBean` Simple factory for shared List instances.
    `class` | `MapFactoryBean` Simple factory for shared Map instances.
    `class` | `MethodInvokingBean` Simple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast to `MethodInvokingFactoryBean`).
    `class` | `MethodInvokingFactoryBean` `FactoryBean` which returns a value which is the result of a static or instance method invocation.
    `class` | `ObjectFactoryCreatingFactoryBean` A `FactoryBean` implementation that returns a value which is an `ObjectFactory` that in turn returns a bean sourced from a `BeanFactory`.
    `class` | `PlaceholderConfigurerSupport` Abstract base class for property resource configurers that resolve placeholders in bean definition property values.
    `class` | `PreferencesPlaceholderConfigurer` Deprecated. as of 5.2, along with `PropertyPlaceholderConfigurer`
    `class` | `PropertyPathFactoryBean` `FactoryBean` that evaluates a property path on a given target object.
    `class` | `PropertyPlaceholderConfigurer` Deprecated. as of 5.2; use `org.springframework.context.support.PropertySourcesPlaceholderConfigurer` instead which is more flexible through taking advantage of the `Environment` and `PropertySource` mechanisms.
    `class` | `ProviderCreatingFactoryBean` A `FactoryBean` implementation that returns a value which is a JSR-330 `Provider` that in turn returns a bean sourced from a `BeanFactory`.
    `class` | `ServiceLocatorFactoryBean` A `FactoryBean` implementation that takes an interface which must have one or more methods with the signatures `MyType xxx()` or `MyType xxx(MyIdType id)` (typically, `MyService getService()` or `MyService getService(String id)`) and creates a dynamic proxy which implements that interface, delegating to an underlying `BeanFactory`.
    `class` | `SetFactoryBean` Simple factory for shared Set instances.

  - ### Uses of Aware in org.springframework.beans.factory.serviceloader

    Classes in org.springframework.beans.factory.serviceloader that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractServiceLoaderBasedFactoryBean` Abstract base class for FactoryBeans operating on the JDK 1.6 `ServiceLoader` facility.
    `class` | `ServiceFactoryBean` `FactoryBean` that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6 `ServiceLoader` facility.
    `class` | `ServiceListFactoryBean` `FactoryBean` that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6 `ServiceLoader` facility.
    `class` | `ServiceLoaderFactoryBean` `FactoryBean` that exposes the JDK 1.6 `ServiceLoader` for the configured service class.

  - ### Uses of Aware in org.springframework.beans.factory.support

    Classes in org.springframework.beans.factory.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `GenericTypeAwareAutowireCandidateResolver` Basic `AutowireCandidateResolver` that performs a full generic type match with the candidate's type if the dependency is declared as a generic type (e.g.

  - ### Uses of Aware in org.springframework.beans.factory.wiring

    Classes in org.springframework.beans.factory.wiring that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanConfigurerSupport` Convenient base class for bean configurers that can perform Dependency Injection on objects (however they may be created).

  - ### Uses of Aware in org.springframework.cache.annotation

    Classes in org.springframework.cache.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractCachingConfiguration` Abstract base `@Configuration` class providing common structure for enabling Spring's annotation-driven cache management capability.
    `class` | `ProxyCachingConfiguration` `@Configuration` class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven cache management.

  - ### Uses of Aware in org.springframework.cache.aspectj

    Classes in org.springframework.cache.aspectj that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AspectJCachingConfiguration` `@Configuration` class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven cache management.
    `class` | `AspectJJCacheConfiguration` `@Configuration` class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven cache management for standard JSR-107 annotations.

  - ### Uses of Aware in org.springframework.cache.concurrent

    Classes in org.springframework.cache.concurrent that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ConcurrentMapCacheFactoryBean` `FactoryBean` for easy configuration of a `ConcurrentMapCache` when used within a Spring container.
    `class` | `ConcurrentMapCacheManager` `CacheManager` implementation that lazily builds `ConcurrentMapCache` instances for each `ConcurrentMapCacheManager.getCache(java.lang.String)` request.

  - ### Uses of Aware in org.springframework.cache.ehcache

    Classes in org.springframework.cache.ehcache that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `EhCacheFactoryBean` `FactoryBean` that creates a named EhCache `Cache` instance (or a decorator that implements the `Ehcache` interface), representing a cache region within an EhCache `CacheManager`.

  - ### Uses of Aware in org.springframework.cache.interceptor

    Classes in org.springframework.cache.interceptor that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanFactoryCacheOperationSourceAdvisor` Advisor driven by a `CacheOperationSource`, used to include a cache advice bean for methods that are cacheable.
    `class` | `CacheAspectSupport` Base class for caching aspects, such as the `CacheInterceptor` or an AspectJ aspect.
    `class` | `CacheInterceptor` AOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure (`Cache`).
    `class` | `CacheProxyFactoryBean` Proxy factory bean for simplified declarative caching handling.

  - ### Uses of Aware in org.springframework.cache.jcache

    Classes in org.springframework.cache.jcache that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JCacheManagerFactoryBean` `FactoryBean` for a JCache `javax.cache.CacheManager`, obtaining a pre-defined `CacheManager` by name through the standard JCache `javax.cache.Caching` class.

  - ### Uses of Aware in org.springframework.cache.jcache.config

    Classes in org.springframework.cache.jcache.config that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractJCacheConfiguration` Abstract JSR-107 specific `@Configuration` class providing common structure for enabling JSR-107 annotation-driven cache management capability.
    `class` | `ProxyJCacheConfiguration` `@Configuration` class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven JSR-107 cache management.

  - ### Uses of Aware in org.springframework.cache.jcache.interceptor

    Classes in org.springframework.cache.jcache.interceptor that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanFactoryJCacheOperationSourceAdvisor` Advisor driven by a `JCacheOperationSource`, used to include a cache advice bean for methods that are cacheable.
    `class` | `DefaultJCacheOperationSource` The default `JCacheOperationSource` implementation delegating default operations to configurable services with sensible defaults when not present.

  - ### Uses of Aware in org.springframework.context

    Subinterfaces of Aware in org.springframework.context
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ApplicationContextAware` Interface to be implemented by any object that wishes to be notified of the `ApplicationContext` that it runs in.
    `interface` | `ApplicationEventPublisherAware` Interface to be implemented by any object that wishes to be notified of the ApplicationEventPublisher (typically the ApplicationContext) that it runs in.
    `interface` | `ApplicationStartupAware` Interface to be implemented by any object that wishes to be notified of the `ApplicationStartup` that it runs with.
    `interface` | `EmbeddedValueResolverAware` Interface to be implemented by any object that wishes to be notified of a `StringValueResolver` for the resolution of embedded definition values.
    `interface` | `EnvironmentAware` Interface to be implemented by any bean that wishes to be notified of the `Environment` that it runs in.
    `interface` | `MessageSourceAware` Interface to be implemented by any object that wishes to be notified of the MessageSource (typically the ApplicationContext) that it runs in.
    `interface` | `ResourceLoaderAware` Interface to be implemented by any object that wishes to be notified of the `ResourceLoader` (typically the ApplicationContext) that it runs in.

  - ### Uses of Aware in org.springframework.context.annotation

    Subinterfaces of Aware in org.springframework.context.annotation
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ImportAware` Interface to be implemented by any @`Configuration` class that wishes to be injected with the `AnnotationMetadata` of the @`Configuration` class that imported it.

    Classes in org.springframework.context.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ClassPathBeanDefinitionScanner` A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry (`BeanFactory` or `ApplicationContext`).
    `class` | `ClassPathScanningCandidateComponentProvider` A component provider that scans for candidate components starting from a specified base package.
    `class` | `CommonAnnotationBeanPostProcessor` `BeanPostProcessor` implementation that supports common Java annotations out of the box, in particular the JSR-250 annotations in the `javax.annotation` package.
    `class` | `ConfigurationClassPostProcessor` `BeanFactoryPostProcessor` used for bootstrapping processing of `@Configuration` classes.
    `class` | `ContextAnnotationAutowireCandidateResolver` Complete implementation of the `AutowireCandidateResolver` strategy interface, providing support for qualifier annotations as well as for lazy resolution driven by the `Lazy` annotation in the `context.annotation` package.
    `class` | `LoadTimeWeavingConfiguration` `@Configuration` class that registers a `LoadTimeWeaver` bean.
    `class` | `MBeanExportConfiguration` `@Configuration` class that registers a `AnnotationMBeanExporter` bean.

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

    Classes in org.springframework.context.event that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractApplicationEventMulticaster` Abstract implementation of the `ApplicationEventMulticaster` interface, providing the basic listener registration facility.
    `class` | `EventListenerMethodProcessor` Registers `EventListener` methods as individual `ApplicationListener` instances.
    `class` | `EventPublicationInterceptor` `Interceptor` that publishes an `ApplicationEvent` to all `ApplicationListeners` registered with an `ApplicationEventPublisher` after each successful method invocation.
    `class` | `SimpleApplicationEventMulticaster` Simple implementation of the `ApplicationEventMulticaster` interface.

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

    Classes in org.springframework.context.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `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` | `ApplicationObjectSupport` Convenient superclass for application objects that want to be aware of the application context, e.g.
    `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` | `DefaultLifecycleProcessor` Spring's default implementation of the `LifecycleProcessor` strategy.
    `class` | `EmbeddedValueResolutionSupport` Convenient base class for components with a need for embedded value resolution (i.e.
    `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` | `LiveBeansView` Deprecated. as of 5.3, in favor of using Spring Boot actuators for such needs
    `class` | `PropertySourcesPlaceholderConfigurer` Specialization of `PlaceholderConfigurerSupport` that resolves ${...} placeholders within bean definition property values and `@Value` annotations against the current Spring `Environment` and its set of `PropertySources`.
    `class` | `ReloadableResourceBundleMessageSource` Spring-specific `MessageSource` implementation that accesses resource bundles using specified basenames, participating in the Spring `ApplicationContext`'s resource loading.
    `class` | `ResourceBundleMessageSource` `MessageSource` implementation that accesses resource bundles using specified basenames.

  - ### Uses of Aware in org.springframework.context.weaving

    Subinterfaces of Aware in org.springframework.context.weaving
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `LoadTimeWeaverAware` Interface to be implemented by any object that wishes to be notified of the application context's default `LoadTimeWeaver`.

    Classes in org.springframework.context.weaving that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AspectJWeavingEnabler` Post-processor that registers AspectJ's `ClassPreProcessorAgentAdapter` with the Spring application context's default `LoadTimeWeaver`.
    `class` | `DefaultContextLoadTimeWeaver` Default `LoadTimeWeaver` bean for use in an application context, decorating an automatically detected internal `LoadTimeWeaver`.
    `class` | `LoadTimeWeaverAwareProcessor` `BeanPostProcessor` implementation that passes the context's default `LoadTimeWeaver` to beans that implement the `LoadTimeWeaverAware` interface.

  - ### Uses of Aware in org.springframework.dao.annotation

    Classes in org.springframework.dao.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `PersistenceExceptionTranslationPostProcessor` Bean post-processor that automatically applies persistence exception translation to any bean marked with Spring's @`Repository` annotation, adding a corresponding `PersistenceExceptionTranslationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).

  - ### Uses of Aware in org.springframework.dao.support

    Classes in org.springframework.dao.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `PersistenceExceptionTranslationInterceptor` AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.

  - ### Uses of Aware in org.springframework.ejb.access

    Classes in org.springframework.ejb.access that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `LocalStatelessSessionProxyFactoryBean` Convenient `FactoryBean` for local Stateless Session Bean (SLSB) proxies.
    `class` | `SimpleRemoteStatelessSessionProxyFactoryBean` Convenient `FactoryBean` for remote SLSB proxies.

  - ### Uses of Aware in org.springframework.format.datetime

    Classes in org.springframework.format.datetime that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DateTimeFormatAnnotationFormatterFactory` Formats fields annotated with the `DateTimeFormat` annotation using a `DateFormatter`.

  - ### Uses of Aware in org.springframework.format.datetime.joda

    Classes in org.springframework.format.datetime.joda that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JodaDateTimeFormatAnnotationFormatterFactory` Deprecated. as of 5.3, in favor of standard JSR-310 support

  - ### Uses of Aware in org.springframework.format.datetime.standard

    Classes in org.springframework.format.datetime.standard that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Jsr310DateTimeFormatAnnotationFormatterFactory` Formats fields annotated with the `DateTimeFormat` annotation using the JSR-310 `java.time` package in JDK 8.

  - ### Uses of Aware in org.springframework.format.number

    Classes in org.springframework.format.number that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `NumberFormatAnnotationFormatterFactory` Formats fields annotated with the `NumberFormat` annotation.

  - ### Uses of Aware in org.springframework.format.number.money

    Classes in org.springframework.format.number.money that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Jsr354NumberFormatAnnotationFormatterFactory` Formats `MonetaryAmount` fields annotated with Spring's common `NumberFormat` annotation.

  - ### Uses of Aware in org.springframework.format.support

    Classes in org.springframework.format.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultFormattingConversionService` A specialization of `FormattingConversionService` configured by default with converters and formatters appropriate for most applications.
    `class` | `FormattingConversionService` A `ConversionService` implementation designed to be configured as a `FormatterRegistry`.
    `class` | `FormattingConversionServiceFactoryBean` A factory providing convenient access to a `FormattingConversionService` configured with converters and formatters for common types such as numbers and datetimes.

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

    Classes in org.springframework.http.converter.json that implement Aware
    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 Aware in org.springframework.jca.context

    Subinterfaces of Aware in org.springframework.jca.context
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BootstrapContextAware` Interface to be implemented by any object that wishes to be notified of the BootstrapContext (typically determined by the `ResourceAdapterApplicationContext`) that it runs in.

  - ### Uses of Aware in org.springframework.jca.endpoint

    Classes in org.springframework.jca.endpoint that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractMessageEndpointFactory` Abstract base implementation of the JCA 1.7 `MessageEndpointFactory` interface, providing transaction management capabilities as well as ClassLoader exposure for endpoint invocations.
    `class` | `GenericMessageEndpointFactory` Generic implementation of the JCA 1.7 `MessageEndpointFactory` interface, providing transaction management capabilities for any kind of message listener object (e.g.

  - ### Uses of Aware in org.springframework.jca.work

    Classes in org.springframework.jca.work that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `WorkManagerTaskExecutor` `TaskExecutor` implementation that delegates to a JCA 1.7 WorkManager, implementing the `WorkManager` interface.

  - ### Uses of Aware in org.springframework.jdbc.config

    Classes in org.springframework.jdbc.config that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SortedResourcesFactoryBean` `FactoryBean` implementation that takes a list of location Strings and creates a sorted array of `Resource` instances.

  - ### Uses of Aware in org.springframework.jdbc.datasource.lookup

    Classes in org.springframework.jdbc.datasource.lookup that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanFactoryDataSourceLookup` `DataSourceLookup` implementation based on a Spring `BeanFactory`.

  - ### Uses of Aware in org.springframework.jms.annotation

    Classes in org.springframework.jms.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JmsListenerAnnotationBeanPostProcessor` Bean post-processor that registers methods annotated with `JmsListener` to be invoked by a JMS message listener container created under the cover by a `JmsListenerContainerFactory` according to the attributes of the annotation.

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

    Classes in org.springframework.jms.config that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JmsListenerEndpointRegistrar` Helper bean for registering `JmsListenerEndpoint` with a `JmsListenerEndpointRegistry`.
    `class` | `JmsListenerEndpointRegistry` Creates the necessary `MessageListenerContainer` instances for the registered endpoints.
    `class` | `MethodJmsListenerEndpoint` A `JmsListenerEndpoint` providing the method to invoke to process an incoming message for this endpoint.

  - ### Uses of Aware in org.springframework.jms.listener

    Classes in org.springframework.jms.listener that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractJmsListeningContainer` Common base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt).
    `class` | `AbstractMessageListenerContainer` Abstract base class for Spring message listener container implementations.
    `class` | `AbstractPollingMessageListenerContainer` Base class for listener container implementations which are based on polling.
    `class` | `DefaultMessageListenerContainer` Message listener container variant that uses plain JMS client APIs, specifically a loop of `MessageConsumer.receive()` calls that also allow for transactional reception of messages (registering them with XA transactions).
    `class` | `SimpleMessageListenerContainer` Message listener container that uses the plain JMS client API's `MessageConsumer.setMessageListener()` method to create concurrent MessageConsumers for the specified listeners.

  - ### Uses of Aware in org.springframework.jms.listener.endpoint

    Classes in org.springframework.jms.listener.endpoint that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JmsMessageEndpointFactory` JMS-specific implementation of the JCA 1.7 `MessageEndpointFactory` interface, providing transaction management capabilities for a JMS listener object (e.g.
    `class` | `JmsMessageEndpointManager` Extension of the generic JCA 1.5 `GenericMessageEndpointManager`, adding JMS-specific support for ActivationSpec configuration.

  - ### Uses of Aware in org.springframework.jms.remoting

    Classes in org.springframework.jms.remoting that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JmsInvokerProxyFactoryBean` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `JmsInvokerServiceExporter` Deprecated. as of 5.3 (phasing out serialization-based remoting)

  - ### Uses of Aware in org.springframework.jms.support.converter

    Classes in org.springframework.jms.support.converter that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MappingJackson2MessageConverter` Message converter that uses Jackson 2.x to convert messages to and from JSON.

  - ### Uses of Aware in org.springframework.jms.support.destination

    Classes in org.springframework.jms.support.destination that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanFactoryDestinationResolver` `DestinationResolver` implementation based on a Spring `BeanFactory`.

  - ### Uses of Aware in org.springframework.jmx.access

    Classes in org.springframework.jmx.access that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MBeanClientInterceptor` `MethodInterceptor` that routes calls to an MBean running on the supplied `MBeanServerConnection`.
    `class` | `MBeanProxyFactoryBean` Creates a proxy to a managed resource running either locally or remotely.

  - ### Uses of Aware in org.springframework.jmx.export

    Classes in org.springframework.jmx.export that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MBeanExporter` JMX exporter that allows for exposing any Spring-managed bean to a JMX `MBeanServer`, without the need to define any JMX-specific information in the bean classes.

  - ### Uses of Aware in org.springframework.jmx.export.annotation

    Classes in org.springframework.jmx.export.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AnnotationJmxAttributeSource` Implementation of the `JmxAttributeSource` interface that reads annotations and exposes the corresponding attributes.
    `class` | `AnnotationMBeanExporter` Convenient subclass of Spring's standard `MBeanExporter`, activating annotation usage for JMX exposure of Spring beans: `ManagedResource`, `ManagedAttribute`, `ManagedOperation`, etc.

  - ### Uses of Aware in org.springframework.jmx.export.assembler

    Classes in org.springframework.jmx.export.assembler that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `InterfaceBasedMBeanInfoAssembler` Subclass of `AbstractReflectiveMBeanInfoAssembler` that allows for the management interface of a bean to be defined using arbitrary interfaces.

  - ### Uses of Aware in org.springframework.jmx.export.notification

    Subinterfaces of Aware in org.springframework.jmx.export.notification
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `NotificationPublisherAware` Interface to be implemented by any Spring-managed resource that is to be registered with an `MBeanServer` and wishes to send JMX `javax.management.Notifications`.

  - ### Uses of Aware in org.springframework.jmx.support

    Classes in org.springframework.jmx.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MBeanServerConnectionFactoryBean` `FactoryBean` that creates a JMX 1.2 `MBeanServerConnection` to a remote `MBeanServer` exposed via a `JMXServerConnector`.

  - ### Uses of Aware in org.springframework.jndi

    Classes in org.springframework.jndi that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JndiObjectFactoryBean` `FactoryBean` that looks up a JNDI object.

  - ### Uses of Aware in org.springframework.messaging.core

    Classes in org.springframework.messaging.core that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanFactoryMessageChannelDestinationResolver` An implementation of `DestinationResolver` that interprets a destination name as the bean name of a `MessageChannel` and looks up the bean in the configured `BeanFactory`.
    `class` | `GenericMessagingTemplate` A messaging template that resolves destinations names to `MessageChannel`'s to send and receive messages from.

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

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

  - ### Uses of Aware in org.springframework.messaging.handler.annotation.support

    Classes in org.springframework.messaging.handler.annotation.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultMessageHandlerMethodFactory` The default `MessageHandlerMethodFactory` implementation creating an `InvocableHandlerMethod` with the necessary `HandlerMethodArgumentResolver` instances to detect and process most of the use cases defined by `MessageMapping`.

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

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

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

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

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

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

  - ### Uses of Aware in org.springframework.messaging.simp.broker

    Classes in org.springframework.messaging.simp.broker that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractBrokerMessageHandler` Abstract base class for a `MessageHandler` that broker messages to registered subscribers.
    `class` | `SimpleBrokerMessageHandler` A "simple" message broker that recognizes the message types defined in `SimpMessageType`, keeps track of subscriptions with the help of a `SubscriptionRegistry` and sends messages to subscribers.

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

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

  - ### Uses of Aware in org.springframework.messaging.simp.stomp

    Classes in org.springframework.messaging.simp.stomp that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `StompBrokerRelayMessageHandler` A `MessageHandler` that handles messages by forwarding them to a STOMP broker.

  - ### Uses of Aware in org.springframework.messaging.support

    Classes in org.springframework.messaging.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractMessageChannel` Abstract base class for `MessageChannel` implementations.
    `class` | `AbstractSubscribableChannel` Abstract base class for `SubscribableChannel` implementations.
    `class` | `ExecutorSubscribableChannel` A `SubscribableChannel` that sends messages to each of its subscribers.

  - ### Uses of Aware in org.springframework.orm.hibernate5

    Classes in org.springframework.orm.hibernate5 that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HibernateTransactionManager` `PlatformTransactionManager` implementation for a single Hibernate `SessionFactory`.
    `class` | `LocalSessionFactoryBean` `FactoryBean` that creates a Hibernate `SessionFactory`.

  - ### Uses of Aware in org.springframework.orm.hibernate5.support

    Classes in org.springframework.orm.hibernate5.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `OpenSessionInViewFilter` Servlet Filter that binds a Hibernate Session to the thread for the entire processing of the request.

  - ### Uses of Aware in org.springframework.orm.jpa

    Classes in org.springframework.orm.jpa that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractEntityManagerFactoryBean` Abstract `FactoryBean` that creates a local JPA `EntityManagerFactory` instance within a Spring application context.
    `class` | `EntityManagerFactoryAccessor` Base class for any class that needs to access a JPA `EntityManagerFactory`, usually in order to obtain a JPA `EntityManager`.
    `class` | `JpaTransactionManager` `PlatformTransactionManager` implementation for a single JPA `EntityManagerFactory`.
    `class` | `LocalContainerEntityManagerFactoryBean` `FactoryBean` that creates a JPA `EntityManagerFactory` according to JPA's standard container bootstrap contract.
    `class` | `LocalEntityManagerFactoryBean` `FactoryBean` that creates a JPA `EntityManagerFactory` according to JPA's standard standalone bootstrap contract.

  - ### Uses of Aware in org.springframework.orm.jpa.persistenceunit

    Classes in org.springframework.orm.jpa.persistenceunit that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultPersistenceUnitManager` Default implementation of the `PersistenceUnitManager` interface.

  - ### Uses of Aware in org.springframework.orm.jpa.support

    Classes in org.springframework.orm.jpa.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `OpenEntityManagerInViewFilter` Servlet Filter that binds a JPA EntityManager to the thread for the entire processing of the request.
    `class` | `OpenEntityManagerInViewInterceptor` Spring web request interceptor that binds a JPA EntityManager to the thread for the entire processing of the request.
    `class` | `PersistenceAnnotationBeanPostProcessor` BeanPostProcessor that processes `PersistenceUnit` and `PersistenceContext` annotations, for injection of the corresponding JPA resources `EntityManagerFactory` and `EntityManager`.
    `class` | `SharedEntityManagerBean` `FactoryBean` that exposes a shared JPA `EntityManager` reference for a given EntityManagerFactory.

  - ### Uses of Aware in org.springframework.orm.jpa.vendor

    Classes in org.springframework.orm.jpa.vendor that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HibernateJpaSessionFactoryBean` Deprecated. as of Spring Framework 4.3.12 against Hibernate 5.2, in favor of a custom solution based on `EntityManagerFactory.unwrap(java.lang.Class<T>)` with explicit qualifiers and/or primary markers

  - ### Uses of Aware in org.springframework.oxm.jaxb

    Classes in org.springframework.oxm.jaxb that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Jaxb2Marshaller` Implementation of the `GenericMarshaller` interface for JAXB 2.2.

  - ### Uses of Aware in org.springframework.oxm.xstream

    Classes in org.springframework.oxm.xstream that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `XStreamMarshaller` Implementation of the `Marshaller` interface for XStream.

  - ### Uses of Aware in org.springframework.r2dbc.connection.lookup

    Classes in org.springframework.r2dbc.connection.lookup that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanFactoryConnectionFactoryLookup` `ConnectionFactoryLookup` implementation based on a Spring `BeanFactory`.

  - ### Uses of Aware in org.springframework.remoting.caucho

    Classes in org.springframework.remoting.caucho that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `HessianClientInterceptor` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `HessianExporter` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `HessianProxyFactoryBean` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `HessianServiceExporter` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `SimpleHessianServiceExporter` Deprecated. as of Spring Framework 5.1, in favor of `HessianServiceExporter`

  - ### Uses of Aware in org.springframework.remoting.httpinvoker

    Classes in org.springframework.remoting.httpinvoker that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractHttpInvokerRequestExecutor` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `HttpComponentsHttpInvokerRequestExecutor` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `HttpInvokerClientInterceptor` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `HttpInvokerProxyFactoryBean` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `HttpInvokerServiceExporter` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `SimpleHttpInvokerRequestExecutor` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `SimpleHttpInvokerServiceExporter` Deprecated. as of Spring Framework 5.1, in favor of `HttpInvokerServiceExporter`

  - ### Uses of Aware in org.springframework.remoting.jaxws

    Classes in org.springframework.remoting.jaxws that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractJaxWsServiceExporter` Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS `WebService` annotation).
    `class` | `JaxWsPortClientInterceptor` `MethodInterceptor` for accessing a specific port of a JAX-WS service.
    `class` | `JaxWsPortProxyFactoryBean` `FactoryBean` for a specific port of a JAX-WS service.
    `class` | `SimpleHttpServerJaxWsServiceExporter` Deprecated. as of Spring Framework 5.1, in favor of `SimpleJaxWsServiceExporter`
    `class` | `SimpleJaxWsServiceExporter` Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS `WebService` annotation) and exporting them with a configured base address (by default "http://localhost:8080/") using the JAX-WS provider's built-in publication support.

  - ### Uses of Aware in org.springframework.remoting.rmi

    Classes in org.springframework.remoting.rmi that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JndiRmiProxyFactoryBean` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `JndiRmiServiceExporter` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `RemoteInvocationSerializingExporter` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `RmiBasedExporter` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `RmiClientInterceptor` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `RmiProxyFactoryBean` Deprecated. as of 5.3 (phasing out serialization-based remoting)
    `class` | `RmiServiceExporter` Deprecated. as of 5.3 (phasing out serialization-based remoting)

  - ### Uses of Aware in org.springframework.remoting.support

    Classes in org.springframework.remoting.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `RemoteAccessor` Abstract base class for classes that access a remote service.
    `class` | `RemoteExporter` Abstract base class for classes that export a remote service.
    `class` | `RemoteInvocationBasedAccessor` Abstract base class for remote service accessors that are based on serialization of `RemoteInvocation` objects.
    `class` | `RemoteInvocationBasedExporter` Abstract base class for remote service exporters that are based on deserialization of `RemoteInvocation` objects.
    `class` | `RemotingSupport` Generic support base class for remote accessor and exporters, providing common bean ClassLoader handling.
    `class` | `UrlBasedRemoteAccessor` Abstract base class for classes that access remote services via URLs.

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

    Classes in org.springframework.scheduling.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractAsyncConfiguration` Abstract base `Configuration` class providing common structure for enabling Spring's asynchronous method execution capability.
    `class` | `AnnotationAsyncExecutionInterceptor` Specialization of `AsyncExecutionInterceptor` that delegates method execution to an `Executor` based on the `Async` annotation.
    `class` | `AsyncAnnotationAdvisor` Advisor that activates asynchronous method execution through the `Async` annotation.
    `class` | `AsyncAnnotationBeanPostProcessor` Bean post-processor that automatically applies asynchronous invocation behavior to any bean that carries the `Async` annotation at class or method-level by adding a corresponding `AsyncAnnotationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all the target's interfaces).
    `class` | `ProxyAsyncConfiguration` `@Configuration` class that registers the Spring infrastructure beans necessary to enable proxy-based asynchronous method execution.
    `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 Aware in org.springframework.scheduling.aspectj

    Classes in org.springframework.scheduling.aspectj that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AspectJAsyncConfiguration` `@Configuration` class that registers the Spring infrastructure beans necessary to enable AspectJ-based asynchronous method execution.

  - ### Uses of Aware in org.springframework.scheduling.concurrent

    Classes in org.springframework.scheduling.concurrent that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ExecutorConfigurationSupport` Base class for setting up a `ExecutorService` (typically a `ThreadPoolExecutor` or `ScheduledThreadPoolExecutor`).
    `class` | `ScheduledExecutorFactoryBean` `FactoryBean` that sets up a `ScheduledExecutorService` (by default: a `ScheduledThreadPoolExecutor`) and exposes it for bean references.
    `class` | `ThreadPoolExecutorFactoryBean` JavaBean that allows for configuring a `ThreadPoolExecutor` in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its native `ExecutorService` type.
    `class` | `ThreadPoolTaskExecutor` JavaBean that allows for configuring a `ThreadPoolExecutor` in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a Spring `TaskExecutor`.
    `class` | `ThreadPoolTaskScheduler` A standard implementation of Spring's `TaskScheduler` interface, wrapping a native `ScheduledThreadPoolExecutor` and providing all applicable configuration options for it.

  - ### Uses of Aware in org.springframework.scheduling.config

    Classes in org.springframework.scheduling.config that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `TaskExecutorFactoryBean` `FactoryBean` for creating `ThreadPoolTaskExecutor` instances, primarily used behind the XML task namespace.

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

    Subinterfaces of Aware in org.springframework.scheduling.quartz
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `SchedulerContextAware` Callback interface to be implemented by Spring-managed Quartz artifacts that need access to the SchedulerContext (without having natural access to it).

    Classes in org.springframework.scheduling.quartz that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CronTriggerFactoryBean` A Spring `FactoryBean` for creating a Quartz `CronTrigger` instance, supporting bean-style usage for trigger configuration.
    `class` | `JobDetailFactoryBean` A Spring `FactoryBean` for creating a Quartz `JobDetail` instance, supporting bean-style usage for JobDetail configuration.
    `class` | `MethodInvokingJobDetailFactoryBean` `FactoryBean` that exposes a `JobDetail` object which delegates job execution to a specified (static or non-static) method.
    `class` | `SchedulerAccessor` Common base class for accessing a Quartz Scheduler, i.e.
    `class` | `SchedulerAccessorBean` Spring bean-style class for accessing a Quartz Scheduler, i.e.
    `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` | `SimpleTriggerFactoryBean` A Spring `FactoryBean` for creating a Quartz `SimpleTrigger` instance, supporting bean-style usage for trigger configuration.
    `class` | `SpringBeanJobFactory` Subclass of `AdaptableJobFactory` that also supports Spring-style dependency injection on bean properties.

  - ### Uses of Aware in org.springframework.scheduling.support

    Classes in org.springframework.scheduling.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MethodInvokingRunnable` Adapter that implements the `Runnable` interface as a configurable method invocation based on Spring's MethodInvoker.

  - ### Uses of Aware in org.springframework.scripting.bsh

    Classes in org.springframework.scripting.bsh that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BshScriptEvaluator` BeanShell-based implementation of Spring's `ScriptEvaluator` strategy interface.
    `class` | `BshScriptFactory` `ScriptFactory` implementation for a BeanShell script.

  - ### Uses of Aware in org.springframework.scripting.groovy

    Classes in org.springframework.scripting.groovy that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `GroovyScriptEvaluator` Groovy-based implementation of Spring's `ScriptEvaluator` strategy interface.
    `class` | `GroovyScriptFactory` `ScriptFactory` implementation for a Groovy script.

  - ### Uses of Aware in org.springframework.scripting.support

    Classes in org.springframework.scripting.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ScriptFactoryPostProcessor` `BeanPostProcessor` that handles `ScriptFactory` definitions, replacing each factory with the actual scripted Java object generated by it.
    `class` | `StandardScriptEvaluator` `javax.script` (JSR-223) based implementation of Spring's `ScriptEvaluator` strategy interface.
    `class` | `StandardScriptFactory` `ScriptFactory` implementation based on the JSR-223 script engine abstraction (as included in Java).

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

    Classes in org.springframework.test.context.junit4 that implement Aware
    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 Aware in org.springframework.test.context.testng

    Classes in org.springframework.test.context.testng that implement Aware
    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 Aware in org.springframework.transaction.annotation

    Classes in org.springframework.transaction.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractTransactionManagementConfiguration` Abstract base `@Configuration` class providing common structure for enabling Spring's annotation-driven transaction management capability.
    `class` | `AnnotationTransactionAttributeSource` Implementation of the `TransactionAttributeSource` interface for working with transaction metadata in JDK 1.5+ annotation format.
    `class` | `ProxyTransactionManagementConfiguration` `@Configuration` class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven transaction management.

  - ### Uses of Aware in org.springframework.transaction.aspectj

    Classes in org.springframework.transaction.aspectj that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AspectJJtaTransactionManagementConfiguration` `@Configuration` class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven transaction management for the JTA 1.2 `Transactional` annotation in addition to Spring's own `Transactional` annotation.
    `class` | `AspectJTransactionManagementConfiguration` `@Configuration` class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven transaction management for Spring's own `Transactional` annotation.

  - ### Uses of Aware in org.springframework.transaction.interceptor

    Classes in org.springframework.transaction.interceptor that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractFallbackTransactionAttributeSource` Abstract implementation of `TransactionAttributeSource` that caches attributes for methods and implements a fallback policy: 1.
    `class` | `BeanFactoryTransactionAttributeSourceAdvisor` Advisor driven by a `TransactionAttributeSource`, used to include a transaction advice bean for methods that are transactional.
    `class` | `MethodMapTransactionAttributeSource` Simple `TransactionAttributeSource` implementation that allows attributes to be stored per method in a `Map`.
    `class` | `NameMatchTransactionAttributeSource` Simple `TransactionAttributeSource` implementation that allows attributes to be matched by registered name.
    `class` | `TransactionAspectSupport` Base class for transactional aspects, such as the `TransactionInterceptor` or an AspectJ aspect.
    `class` | `TransactionInterceptor` AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (`PlatformTransactionManager`/ `ReactiveTransactionManager`).
    `class` | `TransactionProxyFactoryBean` Proxy factory bean for simplified declarative transaction handling.

  - ### Uses of Aware in org.springframework.ui.context.support

    Classes in org.springframework.ui.context.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ResourceBundleThemeSource` `ThemeSource` implementation that looks up an individual `ResourceBundle` per theme.

  - ### Uses of Aware in org.springframework.ui.freemarker

    Classes in org.springframework.ui.freemarker that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `FreeMarkerConfigurationFactoryBean` Factory bean that creates a FreeMarker Configuration and provides it as bean reference.

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

    Classes in org.springframework.validation.beanvalidation that implement Aware
    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` | `MethodValidationPostProcessor` A convenient `BeanPostProcessor` implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.
    `class` | `OptionalValidatorFactoryBean` `LocalValidatorFactoryBean` subclass that simply turns `Validator` calls into no-ops in case of no Bean Validation provider being available.

  - ### Uses of Aware in org.springframework.web.accept

    Classes in org.springframework.web.accept that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ContentNegotiationManagerFactoryBean` Factory to create a `ContentNegotiationManager` and configure it with `ContentNegotiationStrategy` instances.

  - ### Uses of Aware in org.springframework.web.context

    Subinterfaces of Aware in org.springframework.web.context
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ServletConfigAware` Interface to be implemented by any object that wishes to be notified of the `ServletConfig` (typically determined by the `WebApplicationContext`) that it runs in.
    `interface` | `ServletContextAware` Interface to be implemented by any object that wishes to be notified of the `ServletContext` (typically determined by the `WebApplicationContext`) that it runs in.

  - ### Uses of Aware in org.springframework.web.context.request.async

    Classes in org.springframework.web.context.request.async that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `WebAsyncTask<V>` Holder for a `Callable`, a timeout value, and a task executor.

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

    Classes in org.springframework.web.context.support that implement Aware
    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` classes, but also plain `@Component` classes as well as JSR-330 compliant classes using `javax.inject` annotations.
    `class` | `GroovyWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by a `GroovyBeanDefinitionReader`.
    `class` | `ServletContextAttributeExporter` Exporter that takes Spring-defined objects and exposes them as ServletContext attributes.
    `class` | `ServletContextAttributeFactoryBean` `FactoryBean` that fetches a specific, existing ServletContext attribute.
    `class` | `ServletContextLiveBeansView` Deprecated. as of 5.3, in favor of using Spring Boot actuators for such needs
    `class` | `ServletContextParameterFactoryBean` `FactoryBean` that retrieves a specific ServletContext init parameter (that is, a "context-param" defined in `web.xml`).
    `class` | `WebApplicationObjectSupport` Convenient superclass for application objects running in a `WebApplicationContext`.
    `class` | `XmlWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

  - ### Uses of Aware in org.springframework.web.filter

    Classes in org.springframework.web.filter that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractRequestLoggingFilter` Base class for `Filter`s that perform logging operations before and after a request is processed.
    `class` | `CharacterEncodingFilter` Servlet Filter that allows one to specify a character encoding for requests.
    `class` | `CommonsRequestLoggingFilter` Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.
    `class` | `CorsFilter` `Filter` to handle CORS pre-flight requests and intercept CORS simple and actual requests with a `CorsProcessor`, and to update the response, e.g.
    `class` | `DelegatingFilterProxy` Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.
    `class` | `FormContentFilter` `Filter` that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.
    `class` | `ForwardedHeaderFilter` Extract values from "Forwarded" and "X-Forwarded-*" headers, wrap the request and response, and make they reflect the client-originated protocol and address in the following methods: `getServerName()` `getServerPort()` `getScheme()` `isSecure()` `sendRedirect(String)`.
    `class` | `GenericFilterBean` Simple base implementation of `Filter` which treats its config parameters (`init-param` entries within the `filter` tag in `web.xml`) as bean properties.
    `class` | `HiddenHttpMethodFilter` `Filter` that converts posted method parameters into HTTP methods, retrievable via `HttpServletRequest.getMethod()`.
    `class` | `HttpPutFormContentFilter` Deprecated. as of 5.1 in favor of `FormContentFilter` which is the same but also handles DELETE.
    `class` | `OncePerRequestFilter` Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.
    `class` | `RelativeRedirectFilter` Overrides `HttpServletResponse.sendRedirect(String)` and handles it by setting the HTTP status and "Location" headers, which keeps the Servlet container from re-writing relative redirect URLs into absolute ones.
    `class` | `RequestContextFilter` Servlet Filter that exposes the request to the current thread, through both `LocaleContextHolder` and `RequestContextHolder`.
    `class` | `ServletContextRequestLoggingFilter` Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.
    `class` | `ShallowEtagHeaderFilter` `Filter` that generates an `ETag` value based on the content on the response.

  - ### Uses of Aware in org.springframework.web.multipart.commons

    Classes in org.springframework.web.multipart.commons that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CommonsMultipartResolver` Servlet-based `MultipartResolver` implementation for Apache Commons FileUpload 1.2 or above.

  - ### Uses of Aware in org.springframework.web.multipart.support

    Classes in org.springframework.web.multipart.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MultipartFilter` Servlet Filter that resolves multipart requests via a `MultipartResolver`.

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

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

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

    Classes in org.springframework.web.reactive.config that implement Aware
    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 Aware in org.springframework.web.reactive.function.server.support

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

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

    Classes in org.springframework.web.reactive.handler that implement Aware
    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 Aware in org.springframework.web.reactive.resource

    Classes in org.springframework.web.reactive.resource that implement Aware
    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 Aware in org.springframework.web.reactive.result.method

    Classes in org.springframework.web.reactive.result.method that implement Aware
    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 Aware in org.springframework.web.reactive.result.method.annotation

    Classes in org.springframework.web.reactive.result.method.annotation that implement Aware
    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 Aware in org.springframework.web.reactive.result.view

    Classes in org.springframework.web.reactive.result.view that implement Aware
    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 Aware in org.springframework.web.reactive.result.view.freemarker

    Classes in org.springframework.web.reactive.result.view.freemarker that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `FreeMarkerConfigurer` Configures FreeMarker for web usage via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
    `class` | `FreeMarkerView` A `View` implementation that uses the FreeMarker template engine.
    `class` | `FreeMarkerViewResolver` A `ViewResolver` for resolving `FreeMarkerView` instances, i.e.

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

    Classes in org.springframework.web.reactive.result.view.script that implement Aware
    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 Aware in org.springframework.web.servlet

    Classes in org.springframework.web.servlet that implement Aware
    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.
    `class` | `HttpServletBean` Simple extension of `HttpServlet` which treats its config parameters (`init-param` entries within the `servlet` tag in `web.xml`) as bean properties.

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

    Classes in org.springframework.web.servlet.config.annotation that implement Aware
    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 Aware in org.springframework.web.servlet.handler

    Classes in org.springframework.web.servlet.handler that implement Aware
    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.
    `class` | `SimpleServletPostProcessor` `BeanPostProcessor` that applies initialization and destruction callbacks to beans that implement the `Servlet` interface.

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

    Classes in org.springframework.web.servlet.mvc that implement Aware
    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 Aware in org.springframework.web.servlet.mvc.annotation

    Classes in org.springframework.web.servlet.mvc.annotation that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ResponseStatusExceptionResolver` A `HandlerExceptionResolver` that uses the `@ResponseStatus` annotation to map exceptions to HTTP status codes.

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

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

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

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

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

    Classes in org.springframework.web.servlet.resource that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultServletHttpRequestHandler` An `HttpRequestHandler` for serving static files using the Servlet container's "default" Servlet.
    `class` | `ResourceHttpRequestHandler` `HttpRequestHandler` that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.
    `class` | `ResourceUrlEncodingFilter` A filter that wraps the `HttpServletResponse` and overrides its `encodeURL` method in order to translate internal resource request URLs into public URL paths for external use.

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

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

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

    Classes in org.springframework.web.servlet.view that implement Aware
    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 Aware in org.springframework.web.servlet.view.document

    Classes in org.springframework.web.servlet.view.document that implement Aware
    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 Aware in org.springframework.web.servlet.view.feed

    Classes in org.springframework.web.servlet.view.feed that implement Aware
    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 Aware in org.springframework.web.servlet.view.groovy

    Classes in org.springframework.web.servlet.view.groovy that implement Aware
    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 Aware in org.springframework.web.servlet.view.json

    Classes in org.springframework.web.servlet.view.json that implement Aware
    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 Aware in org.springframework.web.servlet.view.tiles3

    Classes in org.springframework.web.servlet.view.tiles3 that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `TilesConfigurer` Helper class to configure Tiles 3.x for the Spring Framework.
    `class` | `TilesView` `View` implementation that renders through the Tiles Request API.
    `class` | `TilesViewResolver` Convenience subclass of `UrlBasedViewResolver` that supports `TilesView` (i.e.

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

    Classes in org.springframework.web.servlet.view.xml that implement Aware
    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 Aware in org.springframework.web.servlet.view.xslt

    Classes in org.springframework.web.servlet.view.xslt that implement Aware
    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 Aware in org.springframework.web.socket.client.standard

    Classes in org.springframework.web.socket.client.standard that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AnnotatedEndpointConnectionManager` WebSocket `connection manager` that connects to the server via `WebSocketContainer` and handles the session with an `@ClientEndpoint` endpoint.
    `class` | `EndpointConnectionManager` WebSocket `connection manager` that connects to the server via `WebSocketContainer` and handles the session with an `Endpoint`.

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

    Classes in org.springframework.web.socket.config.annotation that implement Aware
    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 Aware in org.springframework.web.socket.handler

    Classes in org.springframework.web.socket.handler that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BeanCreatingHandlerProvider<T>` Instantiates a target handler through a Spring `BeanFactory` and also provides an equivalent destroy method.
    `class` | `PerConnectionWebSocketHandler` A `WebSocketHandler` that initializes and destroys a `WebSocketHandler` instance for each WebSocket connection and delegates all other methods to it.

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

    Classes in org.springframework.web.socket.messaging that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `StompSubProtocolHandler` A `SubProtocolHandler` for STOMP that supports versions 1.0, 1.1, and 1.2 of the STOMP specification.
    `class` | `WebSocketAnnotationMethodMessageHandler` A subclass of `SimpAnnotationMethodMessageHandler` to provide support for `ControllerAdvice` with global `@MessageExceptionHandler` methods.

  - ### Uses of Aware in org.springframework.web.socket.server.jetty

    Classes in org.springframework.web.socket.server.jetty that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JettyRequestUpgradeStrategy` A `RequestUpgradeStrategy` for use with Jetty 9.4.

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

    Classes in org.springframework.web.socket.server.standard that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ServerEndpointExporter` Detects beans of type `ServerEndpointConfig` and registers with the standard Java WebSocket runtime.
    `class` | `ServerEndpointRegistration` An implementation of `ServerEndpointConfig` for use in Spring-based applications.
    `class` | `ServletServerContainerFactoryBean` A `FactoryBean` for configuring `ServerContainer`.

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

    Classes in org.springframework.web.socket.server.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultHandshakeHandler` A default `HandshakeHandler` implementation, extending `AbstractHandshakeHandler` with Servlet-specific initialization support.
    `class` | `WebSocketHandlerMapping` Extension of `SimpleUrlHandlerMapping` with support for more precise mapping of WebSocket handshake requests to handlers of type `WebSocketHttpRequestHandler`.
    `class` | `WebSocketHttpRequestHandler` A `HttpRequestHandler` for processing WebSocket handshake requests.

  - ### Uses of Aware in org.springframework.web.socket.sockjs.support

    Classes in org.springframework.web.socket.sockjs.support that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SockJsHttpRequestHandler` An `HttpRequestHandler` that allows mapping a `SockJsService` to requests in a Servlet container.

  - ### Uses of Aware in org.springframework.web.socket.sockjs.transport.handler

    Classes in org.springframework.web.socket.sockjs.transport.handler that implement Aware
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultSockJsService` A default implementation of `SockJsService` with all default `TransportHandler` implementations pre-registered.
    `class` | `WebSocketTransportHandler` WebSocket-based `TransportHandler`.