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
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.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.format.datetime	Formatters for java.util.Date properties.
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.endpoint	This package provides a facility for generic JCA message endpoint management.
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.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 MBeanServers 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.handler.invocation.reactive	Common infrastructure for invoking message handler methods with non-blocking, and reactive contracts.
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.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.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 jakarta.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.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.function.support	Classes supporting the org.springframework.web.servlet.function package.
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.freemarker	Support classes for the integration of FreeMarker as Spring web view technology.
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.script	Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
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 Jakarta 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.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	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	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	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	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	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	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 Advisors 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	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	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	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	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	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	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	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.

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

Classes in org.springframework.beans.factory.config that implement Aware

Modifier and Type	Class	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	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	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	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	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	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	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.interceptor

Classes in org.springframework.cache.interceptor that implement Aware

Modifier and Type	Class	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	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	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	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	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	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	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 provides candidate components from a base package.
class	CommonAnnotationBeanPostProcessor	BeanPostProcessor implementation that supports common Java annotations out of the box, in particular the common annotations in the jakarta.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	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	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	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	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	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	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	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	Description
class	PersistenceExceptionTranslationInterceptor	AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.

Uses of Aware in org.springframework.format.datetime

Classes in org.springframework.format.datetime that implement Aware

Modifier and Type	Class	Description
class	DateTimeFormatAnnotationFormatterFactory	Formats fields annotated with the DateTimeFormat annotation using a DateFormatter.

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

Classes in org.springframework.format.datetime.standard that implement Aware

Modifier and Type	Class	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	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	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	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	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.endpoint

Classes in org.springframework.jca.endpoint that implement Aware

Modifier and Type	Class	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.jdbc.config

Classes in org.springframework.jdbc.config that implement Aware

Modifier and Type	Class	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	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	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	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	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	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.support.converter

Classes in org.springframework.jms.support.converter that implement Aware

Modifier and Type	Class	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	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	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	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	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	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	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	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	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	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	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	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	Description
class	AbstractMethodMessageHandler<T>	Abstract base class for HandlerMethod-based message handling.

Uses of Aware in org.springframework.messaging.handler.invocation.reactive

Classes in org.springframework.messaging.handler.invocation.reactive that implement Aware

Modifier and Type	Class	Description
class	AbstractMethodMessageHandler<T>	Abstract base class for reactive 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	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	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	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	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	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	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	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	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	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	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	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.oxm.jaxb

Classes in org.springframework.oxm.jaxb that implement Aware

Modifier and Type	Class	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	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	Description
class	BeanFactoryConnectionFactoryLookup	ConnectionFactoryLookup implementation based on a Spring BeanFactory.

Uses of Aware in org.springframework.scheduling.annotation

Classes in org.springframework.scheduling.annotation that implement Aware

Modifier and Type	Class	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	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	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	Implementation of Spring's TaskScheduler interface, wrapping a native ScheduledThreadPoolExecutor.

Uses of Aware in org.springframework.scheduling.config

Classes in org.springframework.scheduling.config that implement Aware

Modifier and Type	Class	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	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	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	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	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	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	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	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	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	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	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	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	Description
class	ResourceBundleThemeSource	Deprecated. as of 6.0 in favor of using CSS, without direct replacement

Uses of Aware in org.springframework.ui.freemarker

Classes in org.springframework.ui.freemarker that implement Aware

Modifier and Type	Class	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	Description
class	LocalValidatorFactoryBean	This is the central class for jakarta.validation (JSR-303) setup in a Spring application context: It bootstraps a jakarta.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	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	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	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	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 jakarta.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	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	Description
class	AbstractRequestLoggingFilter	Base class for Filters 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	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	ServerHttpObservationFilter	Filter that creates observations for HTTP exchanges.
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.support

Classes in org.springframework.web.multipart.support that implement Aware

Modifier and Type	Class	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	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	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	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	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	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	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	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.
class	ResponseEntityExceptionHandler	A class with an @ExceptionHandler method that handles all Spring WebFlux raised exceptions by returning a ResponseEntity with RFC 7807 formatted error details in the body.

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	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	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	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	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	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.function.support

Classes in org.springframework.web.servlet.function.support that implement Aware

Modifier and Type	Class	Description
class	RouterFunctionMapping	HandlerMapping implementation that supports RouterFunctions.

Uses of Aware in org.springframework.web.servlet.handler

Classes in org.springframework.web.servlet.handler that implement Aware

Modifier and Type	Class	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	AbstractHandlerMapping	Abstract base class for HandlerMapping implementations.
class	AbstractHandlerMethodMapping<T>	Abstract base class for HandlerMapping implementations that define a mapping between a request and a HandlerMethod.
class	AbstractUrlHandlerMapping	Abstract base class for URL-mapped HandlerMapping implementations.
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.
class	SimpleUrlHandlerMapping	Implementation of the HandlerMapping interface that maps from URLs to request handler beans.

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

Classes in org.springframework.web.servlet.mvc that implement Aware

Modifier and Type	Class	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	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	Description
class	AbstractHandlerMethodAdapter	Abstract base class for HandlerAdapter implementations that support handlers of type 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.servlet.mvc.method.annotation

Classes in org.springframework.web.servlet.mvc.method.annotation that implement Aware

Modifier and Type	Class	Description
class	ExceptionHandlerExceptionResolver	An AbstractHandlerMethodExceptionResolver that resolves exceptions through @ExceptionHandler methods.
class	RequestMappingHandlerAdapter	Extension of AbstractHandlerMethodAdapter that supports @RequestMapping annotated HandlerMethods.
class	RequestMappingHandlerMapping	Creates RequestMappingInfo instances from type and method-level @RequestMapping annotations in @Controller classes.
class	ResponseEntityExceptionHandler	A class with an @ExceptionHandler method that handles all Spring MVC raised exceptions by returning a ResponseEntity with RFC 7807 formatted error details in the body.

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

Classes in org.springframework.web.servlet.resource that implement Aware

Modifier and Type	Class	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.
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.servlet.support

Classes in org.springframework.web.servlet.support that implement Aware

Modifier and Type	Class	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	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	AbstractUrlBasedView	Abstract base class for URL-based views.
class	AbstractView	Abstract base class for View implementations.
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	RedirectView	View that redirects to an absolute, context relative, or current request relative URL.
class	ResourceBundleViewResolver	Deprecated. as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementations
class	UrlBasedViewResolver	Simple implementation of the ViewResolver interface, allowing for direct resolution of symbolic view names to URLs, without explicit mapping definitions.
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	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	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.freemarker

Classes in org.springframework.web.servlet.view.freemarker that implement Aware

Modifier and Type	Class	Description
class	FreeMarkerConfigurer	JavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
class	FreeMarkerView	View using the FreeMarker template engine.
class	FreeMarkerViewResolver	Convenience subclass of UrlBasedViewResolver that supports FreeMarkerView (i.e.

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	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	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.script

Classes in org.springframework.web.servlet.view.script that implement Aware

Modifier and Type	Class	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.view.xml

Classes in org.springframework.web.servlet.view.xml that implement Aware

Modifier and Type	Class	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	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	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	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	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	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.standard

Classes in org.springframework.web.socket.server.standard that implement Aware

Modifier and Type	Class	Description
class	ServerEndpointExporter	Detects beans of type ServerEndpointConfig and registers with the standard Jakarta 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	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	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	Description
class	DefaultSockJsService	A default implementation of SockJsService with all default TransportHandler implementations pre-registered.
class	WebSocketTransportHandler	WebSocket-based TransportHandler.