Uses of Interface
org.springframework.beans.factory.Aware
Package
Description
AspectJ integration package.
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
Base classes enabling auto-proxying based on AspectJ.
Support package for declarative AOP configuration,
with XML schema being the primary configuration format.
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
Bean post-processors for use in ApplicationContexts to simplify AOP usage
by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
Provides miscellaneous interceptor implementations.
Support for AOP-based scoping of target objects, with configurable backend.
Convenience classes for using Spring's AOP API.
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Support package for annotation-driven bean configuration.
SPI interfaces and configuration-related convenience classes for bean factories.
Support package for the Java
ServiceLoader
facility.Classes supporting the
org.springframework.beans.factory
package.Mechanism to determine bean wiring metadata from a bean instance.
Annotations and supporting classes for declarative cache management.
Implementation package for
java.util.concurrent
based caches.AOP-based solution for declarative caching demarcation.
Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
Support package for declarative JSR-107 caching configuration.
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
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.
Annotation support for the Application Context, including JSR-250 "common"
annotations, component-scanning, and Java-based metadata for creating
Spring-managed objects.
Support classes for application events, like standard context events.
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
Load-time weaving support for a Spring application context, building on Spring's
LoadTimeWeaver
abstraction.Annotation support for DAOs.
Support classes for DAO implementations,
providing miscellaneous utility methods.
Formatters for
java.util.Date
properties.Integration with the JSR-310
java.time
package in JDK 8.Formatters for
java.lang.Number
properties.Integration with the JSR-354
javax.money
package.Support classes for the formatting package,
providing common implementations as well as adapters.
Provides HttpMessageConverter implementations for handling JSON.
This package provides a facility for generic JCA message endpoint management.
Defines the Spring JDBC configuration namespace.
Provides a strategy for looking up JDBC DataSources by name.
Annotations and support classes for declarative JMS listener endpoints.
Support package for declarative messaging configuration,
with Java configuration and XML schema support.
This package contains the base message listener container facility.
This package provides JCA-based endpoint management for JMS message listeners.
Provides a MessageConverter abstraction to convert
between Java objects and JMS messages.
Support classes for Spring's JMS framework.
Provides support for accessing remote MBean resources.
This package provides declarative creation and registration of
Spring-managed beans as JMX MBeans.
Annotations for MBean exposure.
Provides a strategy for MBeanInfo assembly.
Provides supporting infrastructure to allow Spring-created MBeans
to send JMX notifications.
Contains support classes for connecting to local and remote
MBeanServer
s
and for exposing an MBeanServer
to remote clients.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.
Defines interfaces and implementation classes for messaging templates.
Support classes for working with annotated message-handling methods with
non-blocking, reactive contracts.
Support classes for working with annotated message-handling methods.
Common infrastructure for invoking message handler methods.
Common infrastructure for invoking message handler methods with non-blocking,
and reactive contracts.
Support classes for working with annotated RSocket stream handling methods.
Support classes for handling messages from simple messaging protocols
(like STOMP).
Provides a "simple" message broker implementation along with an abstract base
class and other supporting types such as a registry for subscriptions.
Configuration support for WebSocket messaging using higher level messaging protocols.
Generic support for simple messaging protocols (like STOMP).
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.Package providing integration of
Hibernate 5.x
with Spring concepts.
Classes supporting the
org.springframework.orm.hibernate5
package.Package providing integration of JPA (Java Persistence API) with Spring concepts.
Internal support for managing JPA persistence units.
Classes supporting the
org.springframework.orm.jpa
package.Package providing integration of JAXB
with Spring's O/X Mapping support.
Package providing integration of XStream
with Spring's O/X Mapping support.
Provides a strategy for looking up R2DBC ConnectionFactories by name.
Annotation support for asynchronous method execution.
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.Support package for declarative scheduling configuration,
with XML schema being the primary configuration format.
Support classes for the open source scheduler
Quartz,
allowing to set up Quartz Schedulers, JobDetails and
Triggers as beans in a Spring context.
Generic support classes for scheduling.
Package providing integration of
BeanShell
(and BeanShell2)
into Spring's scripting infrastructure.
Package providing integration of
Groovy
into Spring's scripting infrastructure.
Support classes for Spring's scripting package.
Support classes for integrating the Spring TestContext Framework
with JUnit 4.12 or higher.
Support classes for integrating the Spring TestContext Framework
with TestNG.
Spring's support for annotation-based transaction demarcation.
AOP-based solution for declarative transaction demarcation.
Classes supporting the org.springframework.ui.context package.
Support classes for setting up
FreeMarker
within a Spring application context.
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.
This package contains classes used to determine the requested the media types in a request.
Contains a variant of the application context interface for web applications,
and the ContextLoaderListener that bootstraps a root web application context.
Support for asynchronous request processing.
Classes supporting the
org.springframework.web.context
package,
such as WebApplicationContext implementations and various utility classes.Provides generic filter base classes allowing for bean-style configuration.
Support classes for the multipart resolution framework.
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.Spring WebFlux configuration infrastructure.
Classes supporting the
org.springframework.web.reactive.function.server
package.Provides HandlerMapping implementations including abstract base classes.
Support classes for serving static resources.
Infrastructure for handler method processing.
Infrastructure for annotation-based handler method processing.
Support for result handling through view resolution.
Support classes for the integration of
FreeMarker
as Spring web view technology.
Support classes for views based on the JSR-223 script engine abstraction
(as included in Java 6+), e.g.
Provides servlets that integrate with the application context
infrastructure, and the core interfaces and classes for the
Spring web MVC framework.
Annotation-based setup for Spring MVC.
Classes supporting the
org.springframework.web.servlet.function
package.Provides standard HandlerMapping implementations,
including abstract base classes for custom implementations.
Standard controller implementations for the Servlet MVC framework that comes with
Spring.
Support package for annotation-based Servlet MVC controllers.
Servlet-based infrastructure for handler method processing,
building on the
org.springframework.web.method
package.MVC infrastructure for annotation-based handler method processing, building on the
org.springframework.web.method.annotation
package.Support classes for serving static resources.
Support classes for Spring's web MVC framework.
Provides standard View and ViewResolver implementations,
including abstract base classes for custom implementations.
Support classes for document generation,
providing View implementations for PDF and Excel.
Support classes for feed generation, providing View implementations for Atom and RSS.
Support classes for the integration of
FreeMarker
as Spring web view technology.
Support classes for the integration of
Groovy Templates as Spring web view technology.
Support classes for providing a View implementation based on JSON serialization.
Support classes for views based on the JSR-223 script engine abstraction
(as included in Java 6+), e.g.
Support classes for providing a View implementation based on XML Marshalling.
Support classes for XSLT,
providing a View implementation for XSLT stylesheets.
Client-side classes for use with standard Java WebSocket endpoints.
Support for annotation-based WebSocket setup in configuration classes.
Convenient
WebSocketHandler
implementations and decorators.WebSocket integration for Spring's messaging module.
Server-side classes for use with standard JSR-356 WebSocket endpoints.
Server-side support classes including container-specific strategies
for upgrading a request.
Support classes for SockJS including an
AbstractSockJsService
implementation.TransportHandler
implementation classes as well as a concrete
SockJsService
.-
Uses of Aware in org.springframework.aop.aspectj
Modifier and TypeClassDescriptionclass
SpringPointcut
implementation that uses the AspectJ weaver to evaluate a pointcut expression.class
Spring AOP Advisor that can be used for any AspectJ pointcut expression. -
Uses of Aware in org.springframework.aop.aspectj.annotation
Modifier and TypeClassDescriptionclass
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
Modifier and TypeClassDescriptionclass
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
Modifier and TypeClassDescriptionclass
FactoryBean
implementation that locates aMethod
on a specified bean.class
Implementation ofAspectInstanceFactory
that locates the aspect from theBeanFactory
using a configured bean name. -
Uses of Aware in org.springframework.aop.framework
Modifier and TypeClassDescriptionclass
Base class forBeanPostProcessor
implementations that apply a Spring AOPAdvisor
to specific beans.class
Convenient superclass forFactoryBean
types that produce singleton-scoped proxy objects.class
FactoryBean
implementation that builds an AOP proxy based on beans in a SpringBeanFactory
.class
Base class with common functionality for proxy processors, in particular ClassLoader management and theProxyProcessorSupport.evaluateProxyInterfaces(java.lang.Class<?>, org.springframework.aop.framework.ProxyFactory)
algorithm. -
Uses of Aware in org.springframework.aop.framework.autoproxy
Modifier and TypeClassDescriptionclass
Generic auto proxy creator that builds AOP proxies for specific beans based on detected Advisors for each bean.class
BeanPostProcessor
implementation that wraps each eligible bean with an AOP proxy, delegating to specified interceptors before invoking the bean itself.class
Extension ofAbstractAutoProxyCreator
which implementsBeanFactoryAware
, 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
Auto proxy creator that identifies beans to proxy via a list of names.class
BeanPostProcessor
implementation that creates AOP proxies based on all candidateAdvisor
s in the currentBeanFactory
.class
Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors. -
Uses of Aware in org.springframework.aop.framework.autoproxy.target
Modifier and TypeClassDescriptionclass
Convenient superclass forTargetSourceCreator
implementations that require creating multiple instances of a prototype bean.class
TargetSourceCreator
that enforces aLazyInitTargetSource
for each bean that is defined as "lazy-init".class
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
Modifier and TypeClassDescriptionclass
Base class for asynchronous method execution aspects, such asorg.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor
ororg.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect
.class
AOP AllianceMethodInterceptor
that processes method invocations asynchronously, using a givenAsyncTaskExecutor
. -
Uses of Aware in org.springframework.aop.scope
Modifier and TypeClassDescriptionclass
Convenient proxy factory bean for scoped objects. -
Uses of Aware in org.springframework.aop.support
Modifier and TypeClassDescriptionclass
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in a BeanFactory.class
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
Modifier and TypeClassDescriptionclass
Base class forTargetSource
implementations that are based on a SpringBeanFactory
, delegating to Spring-managed bean instances.class
Abstract base class for poolingTargetSource
implementations which maintain a pool of target instances, acquiring and releasing a target object from the pool for each method invocation.class
Base class for dynamicTargetSource
implementations that create new prototype bean instances to support a pooling or new-instance-per-invocation strategy.class
TargetSource
implementation that holds objects in a configurable Apache Commons2 Pool.class
TargetSource
that lazily accesses a singleton bean from aBeanFactory
.class
TargetSource
implementation that creates a new instance of the target bean for each request, destroying each instance on release (after each request).class
SimpleTargetSource
implementation, freshly obtaining the specified target bean from its containing SpringBeanFactory
.class
Alternative to an object pool. -
Uses of Aware in org.springframework.beans.factory
Modifier and TypeInterfaceDescriptioninterface
Callback that allows a bean to be aware of the beanclass loader
; that is, the class loader used by the present bean factory to load bean classes.interface
Interface to be implemented by beans that wish to be aware of their owningBeanFactory
.interface
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
Modifier and TypeClassDescriptionclass
BeanPostProcessor
implementation that autowires annotated fields, setter methods, and arbitrary config methods.class
ABeanFactoryPostProcessor
implementation that allows for convenient registration of custom autowire qualifier types.class
AutowireCandidateResolver
implementation that matches bean definition qualifiers againstqualifier annotations
on the field or parameter to be autowired. -
Uses of Aware in org.springframework.beans.factory.config
Modifier and TypeClassDescriptionclass
Simple template superclass forFactoryBean
implementations that creates a singleton or a prototype object, depending on a flag.class
SimpleBeanFactoryPostProcessor
implementation that registers customScope(s)
with the containingConfigurableBeanFactory
.class
FactoryBean
which retrieves a static or non-static field value.class
Simple factory for shared List instances.class
Simple factory for shared Map instances.class
Simple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast toMethodInvokingFactoryBean
).class
FactoryBean
which returns a value which is the result of a static or instance method invocation.class
AFactoryBean
implementation that returns a value which is anObjectFactory
that in turn returns a bean sourced from aBeanFactory
.class
Abstract base class for property resource configurers that resolve placeholders in bean definition property values.class
Deprecated.class
FactoryBean
that evaluates a property path on a given target object.class
Deprecated.as of 5.2; useorg.springframework.context.support.PropertySourcesPlaceholderConfigurer
instead which is more flexible through taking advantage of theEnvironment
andPropertySource
mechanisms.class
AFactoryBean
implementation that returns a value which is a JSR-330Provider
that in turn returns a bean sourced from aBeanFactory
.class
AFactoryBean
implementation that takes an interface which must have one or more methods with the signaturesMyType xxx()
orMyType xxx(MyIdType id)
(typically,MyService getService()
orMyService getService(String id)
) and creates a dynamic proxy which implements that interface, delegating to an underlyingBeanFactory
.class
Simple factory for shared Set instances. -
Uses of Aware in org.springframework.beans.factory.serviceloader
Modifier and TypeClassDescriptionclass
Abstract base class for FactoryBeans operating on the JDK 1.6ServiceLoader
facility.class
FactoryBean
that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6ServiceLoader
facility.class
FactoryBean
that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6ServiceLoader
facility.class
FactoryBean
that exposes the JDK 1.6ServiceLoader
for the configured service class. -
Uses of Aware in org.springframework.beans.factory.support
Modifier and TypeClassDescriptionclass
BasicAutowireCandidateResolver
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
Modifier and TypeClassDescriptionclass
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
Modifier and TypeClassDescriptionclass
Abstract base@Configuration
class providing common structure for enabling Spring's annotation-driven cache management capability.class
@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
Modifier and TypeClassDescriptionclass
@Configuration
class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven cache management.class
@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
Modifier and TypeClassDescriptionclass
FactoryBean
for easy configuration of aConcurrentMapCache
when used within a Spring container.class
CacheManager
implementation that lazily buildsConcurrentMapCache
instances for eachConcurrentMapCacheManager.getCache(java.lang.String)
request. -
Uses of Aware in org.springframework.cache.interceptor
Modifier and TypeClassDescriptionclass
Advisor driven by aCacheOperationSource
, used to include a cache advice bean for methods that are cacheable.class
Base class for caching aspects, such as theCacheInterceptor
or an AspectJ aspect.class
AOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure (Cache
).class
Proxy factory bean for simplified declarative caching handling. -
Uses of Aware in org.springframework.cache.jcache
Modifier and TypeClassDescriptionclass
FactoryBean
for a JCachejavax.cache.CacheManager
, obtaining a pre-definedCacheManager
by name through the standard JCachejavax.cache.Caching
class. -
Uses of Aware in org.springframework.cache.jcache.config
Modifier and TypeClassDescriptionclass
Abstract JSR-107 specific@Configuration
class providing common structure for enabling JSR-107 annotation-driven cache management capability.class
@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
Modifier and TypeClassDescriptionclass
Advisor driven by aJCacheOperationSource
, used to include a cache advice bean for methods that are cacheable.class
The defaultJCacheOperationSource
implementation delegating default operations to configurable services with sensible defaults when not present. -
Uses of Aware in org.springframework.context
Modifier and TypeInterfaceDescriptioninterface
Interface to be implemented by any object that wishes to be notified of theApplicationContext
that it runs in.interface
Interface to be implemented by any object that wishes to be notified of the ApplicationEventPublisher (typically the ApplicationContext) that it runs in.interface
Interface to be implemented by any object that wishes to be notified of theApplicationStartup
that it runs with.interface
Interface to be implemented by any object that wishes to be notified of aStringValueResolver
for the resolution of embedded definition values.interface
Interface to be implemented by any bean that wishes to be notified of theEnvironment
that it runs in.interface
Interface to be implemented by any object that wishes to be notified of the MessageSource (typically the ApplicationContext) that it runs in.interface
Interface to be implemented by any object that wishes to be notified of theResourceLoader
(typically the ApplicationContext) that it runs in. -
Uses of Aware in org.springframework.context.annotation
Modifier and TypeInterfaceDescriptioninterface
Interface to be implemented by any @Configuration
class that wishes to be injected with theAnnotationMetadata
of the @Configuration
class that imported it.Modifier and TypeClassDescriptionclass
A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry (BeanFactory
orApplicationContext
).class
A component provider that provides candidate components from a base package.class
BeanPostProcessor
implementation that supports common Java annotations out of the box, in particular the common annotations in thejakarta.annotation
package.class
BeanFactoryPostProcessor
used for bootstrapping processing of@Configuration
classes.class
Complete implementation of theAutowireCandidateResolver
strategy interface, providing support for qualifier annotations as well as for lazy resolution driven by theLazy
annotation in thecontext.annotation
package.class
@Configuration
class that registers aLoadTimeWeaver
bean.class
@Configuration
class that registers aAnnotationMBeanExporter
bean. -
Uses of Aware in org.springframework.context.event
Modifier and TypeClassDescriptionclass
Abstract implementation of theApplicationEventMulticaster
interface, providing the basic listener registration facility.class
RegistersEventListener
methods as individualApplicationListener
instances.class
Interceptor
that publishes anApplicationEvent
to allApplicationListeners
registered with anApplicationEventPublisher
after each successful method invocation.class
Simple implementation of theApplicationEventMulticaster
interface. -
Uses of Aware in org.springframework.context.support
Modifier and TypeClassDescriptionclass
AbstractRefreshableApplicationContext
subclass that adds common handling of specified config locations.class
Convenient base class forApplicationContext
implementations, drawing configuration from XML documents containing bean definitions understood by anXmlBeanDefinitionReader
.class
Convenient superclass for application objects that want to be aware of the application context, e.g.class
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
Default implementation of theLifecycleProcessor
strategy.class
Convenient base class for components with a need for embedded value resolution (i.e.class
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
Specialization ofPlaceholderConfigurerSupport
that resolves ${...} placeholders within bean definition property values and@Value
annotations against the current SpringEnvironment
and its set ofPropertySources
.class
Spring-specificMessageSource
implementation that accesses resource bundles using specified basenames, participating in the SpringApplicationContext
's resource loading.class
MessageSource
implementation that accesses resource bundles using specified basenames. -
Uses of Aware in org.springframework.context.weaving
Modifier and TypeInterfaceDescriptioninterface
Interface to be implemented by any object that wishes to be notified of the application context's defaultLoadTimeWeaver
.Modifier and TypeClassDescriptionclass
Post-processor that registers AspectJ'sClassPreProcessorAgentAdapter
with the Spring application context's defaultLoadTimeWeaver
.class
DefaultLoadTimeWeaver
bean for use in an application context, decorating an automatically detected internalLoadTimeWeaver
.class
BeanPostProcessor
implementation that passes the context's defaultLoadTimeWeaver
to beans that implement theLoadTimeWeaverAware
interface. -
Uses of Aware in org.springframework.dao.annotation
Modifier and TypeClassDescriptionclass
Bean post-processor that automatically applies persistence exception translation to any bean marked with Spring's @Repository
annotation, adding a correspondingPersistenceExceptionTranslationAdvisor
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
Modifier and TypeClassDescriptionclass
AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator. -
Uses of Aware in org.springframework.format.datetime
Modifier and TypeClassDescriptionclass
Formats fields annotated with theDateTimeFormat
annotation using aDateFormatter
. -
Uses of Aware in org.springframework.format.datetime.standard
Modifier and TypeClassDescriptionclass
Formats fields annotated with theDateTimeFormat
annotation using the JSR-310java.time
package in JDK 8. -
Uses of Aware in org.springframework.format.number
Modifier and TypeClassDescriptionclass
Formats fields annotated with theNumberFormat
annotation. -
Uses of Aware in org.springframework.format.number.money
Modifier and TypeClassDescriptionclass
FormatsMonetaryAmount
fields annotated with Spring's commonNumberFormat
annotation. -
Uses of Aware in org.springframework.format.support
Modifier and TypeClassDescriptionclass
A specialization ofFormattingConversionService
configured by default with converters and formatters appropriate for most applications.class
AConversionService
implementation designed to be configured as aFormatterRegistry
.class
A factory providing convenient access to aFormattingConversionService
configured with converters and formatters for common types such as numbers and datetimes. -
Uses of Aware in org.springframework.http.converter.json
Modifier and TypeClassDescriptionclass
AFactoryBean
for creating a Jackson 2.xObjectMapper
(default) orXmlMapper
(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
Modifier and TypeClassDescriptionclass
Abstract base implementation of the JCA 1.7MessageEndpointFactory
interface, providing transaction management capabilities as well as ClassLoader exposure for endpoint invocations.class
Generic implementation of the JCA 1.7MessageEndpointFactory
interface, providing transaction management capabilities for any kind of message listener object (e.g. -
Uses of Aware in org.springframework.jdbc.config
Modifier and TypeClassDescriptionclass
FactoryBean
implementation that takes a list of location Strings and creates a sorted array ofResource
instances. -
Uses of Aware in org.springframework.jdbc.datasource.lookup
Modifier and TypeClassDescriptionclass
DataSourceLookup
implementation based on a SpringBeanFactory
. -
Uses of Aware in org.springframework.jms.annotation
Modifier and TypeClassDescriptionclass
Bean post-processor that registers methods annotated withJmsListener
to be invoked by a JMS message listener container created under the cover by aJmsListenerContainerFactory
according to the attributes of the annotation. -
Uses of Aware in org.springframework.jms.config
Modifier and TypeClassDescriptionclass
Helper bean for registeringJmsListenerEndpoint
with aJmsListenerEndpointRegistry
.class
Creates the necessaryMessageListenerContainer
instances for the registered endpoints.class
AJmsListenerEndpoint
providing the method to invoke to process an incoming message for this endpoint. -
Uses of Aware in org.springframework.jms.listener
Modifier and TypeClassDescriptionclass
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
Abstract base class for Spring message listener container implementations.class
Base class for listener container implementations which are based on polling.class
Message listener container variant that uses plain JMS client APIs, specifically a loop ofMessageConsumer.receive()
calls that also allow for transactional reception of messages (registering them with XA transactions).class
Message listener container that uses the plain JMS client API'sMessageConsumer.setMessageListener()
method to create concurrent MessageConsumers for the specified listeners. -
Uses of Aware in org.springframework.jms.listener.endpoint
Modifier and TypeClassDescriptionclass
JMS-specific implementation of the JCA 1.7MessageEndpointFactory
interface, providing transaction management capabilities for a JMS listener object (e.g.class
Extension of the generic JCA 1.5GenericMessageEndpointManager
, adding JMS-specific support for ActivationSpec configuration. -
Uses of Aware in org.springframework.jms.support.converter
Modifier and TypeClassDescriptionclass
Message converter that uses Jackson 2.x to convert messages to and from JSON. -
Uses of Aware in org.springframework.jms.support.destination
Modifier and TypeClassDescriptionclass
DestinationResolver
implementation based on a SpringBeanFactory
. -
Uses of Aware in org.springframework.jmx.access
Modifier and TypeClassDescriptionclass
MethodInterceptor
that routes calls to an MBean running on the suppliedMBeanServerConnection
.class
Creates a proxy to a managed resource running either locally or remotely. -
Uses of Aware in org.springframework.jmx.export
Modifier and TypeClassDescriptionclass
JMX exporter that allows for exposing any Spring-managed bean to a JMXMBeanServer
, without the need to define any JMX-specific information in the bean classes. -
Uses of Aware in org.springframework.jmx.export.annotation
Modifier and TypeClassDescriptionclass
Implementation of theJmxAttributeSource
interface that reads annotations and exposes the corresponding attributes.class
Convenient subclass of Spring's standardMBeanExporter
, activating annotation usage for JMX exposure of Spring beans:ManagedResource
,ManagedAttribute
,ManagedOperation
, etc. -
Uses of Aware in org.springframework.jmx.export.assembler
Modifier and TypeClassDescriptionclass
Subclass ofAbstractReflectiveMBeanInfoAssembler
that allows for the management interface of a bean to be defined using arbitrary interfaces. -
Uses of Aware in org.springframework.jmx.export.notification
Modifier and TypeInterfaceDescriptioninterface
Interface to be implemented by any Spring-managed resource that is to be registered with anMBeanServer
and wishes to send JMXjavax.management.Notifications
. -
Uses of Aware in org.springframework.jmx.support
Modifier and TypeClassDescriptionclass
FactoryBean
that creates a JMX 1.2MBeanServerConnection
to a remoteMBeanServer
exposed via aJMXServerConnector
. -
Uses of Aware in org.springframework.jndi
-
Uses of Aware in org.springframework.messaging.core
Modifier and TypeClassDescriptionclass
An implementation ofDestinationResolver
that interprets a destination name as the bean name of aMessageChannel
and looks up the bean in the configuredBeanFactory
.class
A messaging template that resolves destinations names toMessageChannel
's to send and receive messages from. -
Uses of Aware in org.springframework.messaging.handler.annotation.reactive
Modifier and TypeClassDescriptionclass
Extension ofAbstractMethodMessageHandler
for reactive, non-blocking handling of messages via@MessageMapping
methods. -
Uses of Aware in org.springframework.messaging.handler.annotation.support
Modifier and TypeClassDescriptionclass
The defaultMessageHandlerMethodFactory
implementation creating anInvocableHandlerMethod
with the necessaryHandlerMethodArgumentResolver
instances to detect and process most of the use cases defined byMessageMapping
. -
Uses of Aware in org.springframework.messaging.handler.invocation
Modifier and TypeClassDescriptionclass
Abstract base class for HandlerMethod-based message handling. -
Uses of Aware in org.springframework.messaging.handler.invocation.reactive
Modifier and TypeClassDescriptionclass
Abstract base class for reactive HandlerMethod-based message handling. -
Uses of Aware in org.springframework.messaging.rsocket.annotation.support
Modifier and TypeClassDescriptionclass
Extension ofMessageMappingMessageHandler
for handling RSocket requests with@ConnectMapping
and@MessageMapping
methods. -
Uses of Aware in org.springframework.messaging.simp.annotation.support
Modifier and TypeClassDescriptionclass
A handler for messages delegating to@MessageMapping
and@SubscribeMapping
annotated methods. -
Uses of Aware in org.springframework.messaging.simp.broker
Modifier and TypeClassDescriptionclass
Abstract base class for aMessageHandler
that broker messages to registered subscribers.class
A "simple" message broker that recognizes the message types defined inSimpMessageType
, keeps track of subscriptions with the help of aSubscriptionRegistry
and sends messages to subscribers. -
Uses of Aware in org.springframework.messaging.simp.config
Modifier and TypeClassDescriptionclass
Provides essential configuration for handling messages with simple messaging protocols such as STOMP. -
Uses of Aware in org.springframework.messaging.simp.stomp
Modifier and TypeClassDescriptionclass
AMessageHandler
that handles messages by forwarding them to a STOMP broker. -
Uses of Aware in org.springframework.messaging.support
Modifier and TypeClassDescriptionclass
Abstract base class forMessageChannel
implementations.class
Abstract base class forSubscribableChannel
implementations.class
ASubscribableChannel
that sends messages to each of its subscribers. -
Uses of Aware in org.springframework.orm.hibernate5
Modifier and TypeClassDescriptionclass
PlatformTransactionManager
implementation for a single HibernateSessionFactory
.class
FactoryBean
that creates a HibernateSessionFactory
. -
Uses of Aware in org.springframework.orm.hibernate5.support
Modifier and TypeClassDescriptionclass
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
Modifier and TypeClassDescriptionclass
AbstractFactoryBean
that creates a local JPAEntityManagerFactory
instance within a Spring application context.class
Base class for any class that needs to access a JPAEntityManagerFactory
, usually in order to obtain a JPAEntityManager
.class
PlatformTransactionManager
implementation for a single JPAEntityManagerFactory
.class
FactoryBean
that creates a JPAEntityManagerFactory
according to JPA's standard container bootstrap contract.class
FactoryBean
that creates a JPAEntityManagerFactory
according to JPA's standard standalone bootstrap contract. -
Uses of Aware in org.springframework.orm.jpa.persistenceunit
Modifier and TypeClassDescriptionclass
Default implementation of thePersistenceUnitManager
interface. -
Uses of Aware in org.springframework.orm.jpa.support
Modifier and TypeClassDescriptionclass
Servlet Filter that binds a JPA EntityManager to the thread for the entire processing of the request.class
Spring web request interceptor that binds a JPA EntityManager to the thread for the entire processing of the request.class
BeanPostProcessor that processesPersistenceUnit
andPersistenceContext
annotations, for injection of the corresponding JPA resourcesEntityManagerFactory
andEntityManager
.class
FactoryBean
that exposes a shared JPAEntityManager
reference for a given EntityManagerFactory. -
Uses of Aware in org.springframework.oxm.jaxb
Modifier and TypeClassDescriptionclass
Implementation of theGenericMarshaller
interface for JAXB 2.2. -
Uses of Aware in org.springframework.oxm.xstream
Modifier and TypeClassDescriptionclass
Implementation of theMarshaller
interface for XStream. -
Uses of Aware in org.springframework.r2dbc.connection.lookup
Modifier and TypeClassDescriptionclass
ConnectionFactoryLookup
implementation based on a SpringBeanFactory
. -
Uses of Aware in org.springframework.scheduling.annotation
Modifier and TypeClassDescriptionclass
Abstract baseConfiguration
class providing common structure for enabling Spring's asynchronous method execution capability.class
Specialization ofAsyncExecutionInterceptor
that delegates method execution to anExecutor
based on theAsync
annotation.class
Advisor that activates asynchronous method execution through theAsync
annotation.class
Bean post-processor that automatically applies asynchronous invocation behavior to any bean that carries theAsync
annotation at class or method-level by adding a correspondingAsyncAnnotationAdvisor
to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all the target's interfaces).class
@Configuration
class that registers the Spring infrastructure beans necessary to enable proxy-based asynchronous method execution.class
Bean post-processor that registers methods annotated with@Scheduled
to be invoked by aTaskScheduler
according to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation. -
Uses of Aware in org.springframework.scheduling.aspectj
Modifier and TypeClassDescriptionclass
@Configuration
class that registers the Spring infrastructure beans necessary to enable AspectJ-based asynchronous method execution. -
Uses of Aware in org.springframework.scheduling.concurrent
Modifier and TypeClassDescriptionclass
Base class for setting up aExecutorService
(typically aThreadPoolExecutor
orScheduledThreadPoolExecutor
).class
FactoryBean
that sets up aScheduledExecutorService
(by default: aScheduledThreadPoolExecutor
) and exposes it for bean references.class
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its nativeExecutorService
type.class
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a SpringTaskExecutor
.class
Implementation of Spring'sTaskScheduler
interface, wrapping a nativeScheduledThreadPoolExecutor
. -
Uses of Aware in org.springframework.scheduling.config
Modifier and TypeClassDescriptionclass
FactoryBean
for creatingThreadPoolTaskExecutor
instances, primarily used behind the XML task namespace. -
Uses of Aware in org.springframework.scheduling.quartz
Modifier and TypeInterfaceDescriptioninterface
Callback interface to be implemented by Spring-managed Quartz artifacts that need access to the SchedulerContext (without having natural access to it).Modifier and TypeClassDescriptionclass
A SpringFactoryBean
for creating a QuartzCronTrigger
instance, supporting bean-style usage for trigger configuration.class
A SpringFactoryBean
for creating a QuartzJobDetail
instance, supporting bean-style usage for JobDetail configuration.class
FactoryBean
that exposes aJobDetail
object which delegates job execution to a specified (static or non-static) method.class
Common base class for accessing a Quartz Scheduler, i.e.class
Spring bean-style class for accessing a Quartz Scheduler, i.e.class
FactoryBean
that creates and configures a QuartzScheduler
, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.class
A SpringFactoryBean
for creating a QuartzSimpleTrigger
instance, supporting bean-style usage for trigger configuration.class
Subclass ofAdaptableJobFactory
that also supports Spring-style dependency injection on bean properties. -
Uses of Aware in org.springframework.scheduling.support
Modifier and TypeClassDescriptionclass
Adapter that implements theRunnable
interface as a configurable method invocation based on Spring's MethodInvoker. -
Uses of Aware in org.springframework.scripting.bsh
Modifier and TypeClassDescriptionclass
BeanShell-based implementation of Spring'sScriptEvaluator
strategy interface.class
ScriptFactory
implementation for a BeanShell script. -
Uses of Aware in org.springframework.scripting.groovy
Modifier and TypeClassDescriptionclass
Groovy-based implementation of Spring'sScriptEvaluator
strategy interface.class
ScriptFactory
implementation for a Groovy script. -
Uses of Aware in org.springframework.scripting.support
Modifier and TypeClassDescriptionclass
BeanPostProcessor
that handlesScriptFactory
definitions, replacing each factory with the actual scripted Java object generated by it.class
javax.script
(JSR-223) based implementation of Spring'sScriptEvaluator
strategy interface.class
ScriptFactory
implementation based on the JSR-223 script engine abstraction (as included in Java). -
Uses of Aware in org.springframework.test.context.junit4
Modifier and TypeClassDescriptionclass
Abstract base test class which integrates the Spring TestContext Framework with explicitApplicationContext
testing support in a JUnit 4 environment.class
Abstract transactional extension ofAbstractJUnit4SpringContextTests
which adds convenience functionality for JDBC access. -
Uses of Aware in org.springframework.test.context.testng
Modifier and TypeClassDescriptionclass
Abstract base test class which integrates the Spring TestContext Framework with explicitApplicationContext
testing support in a TestNG environment.class
Abstract transactional extension ofAbstractTestNGSpringContextTests
which adds convenience functionality for JDBC access. -
Uses of Aware in org.springframework.transaction.annotation
Modifier and TypeClassDescriptionclass
Abstract base@Configuration
class providing common structure for enabling Spring's annotation-driven transaction management capability.class
Implementation of theTransactionAttributeSource
interface for working with transaction metadata in JDK 1.5+ annotation format.class
@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
Modifier and TypeClassDescriptionclass
@Configuration
class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven transaction management for the JTA 1.2Transactional
annotation in addition to Spring's ownTransactional
annotation.class
@Configuration
class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven transaction management for Spring's ownTransactional
annotation. -
Uses of Aware in org.springframework.transaction.interceptor
Modifier and TypeClassDescriptionclass
Abstract implementation ofTransactionAttributeSource
that caches attributes for methods and implements a fallback policy: 1.class
Advisor driven by aTransactionAttributeSource
, used to include a transaction advice bean for methods that are transactional.class
SimpleTransactionAttributeSource
implementation that allows attributes to be stored per method in aMap
.class
SimpleTransactionAttributeSource
implementation that allows attributes to be matched by registered name.class
Base class for transactional aspects, such as theTransactionInterceptor
or an AspectJ aspect.class
AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (PlatformTransactionManager
/ReactiveTransactionManager
).class
Proxy factory bean for simplified declarative transaction handling. -
Uses of Aware in org.springframework.ui.context.support
Modifier and TypeClassDescriptionclass
Deprecated.as of 6.0 in favor of using CSS, without direct replacement -
Uses of Aware in org.springframework.ui.freemarker
Modifier and TypeClassDescriptionclass
Factory bean that creates a FreeMarker Configuration and provides it as bean reference. -
Uses of Aware in org.springframework.validation.beanvalidation
Modifier and TypeClassDescriptionclass
This is the central class forjakarta.validation
(JSR-303) setup in a Spring application context: It bootstraps ajakarta.validation.ValidationFactory
and exposes it through the SpringValidator
interface as well as through the JSR-303Validator
interface and theValidatorFactory
interface itself.class
A convenientBeanPostProcessor
implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.class
LocalValidatorFactoryBean
subclass that simply turnsValidator
calls into no-ops in case of no Bean Validation provider being available. -
Uses of Aware in org.springframework.web.accept
Modifier and TypeClassDescriptionclass
Factory to create aContentNegotiationManager
and configure it withContentNegotiationStrategy
instances. -
Uses of Aware in org.springframework.web.context
Modifier and TypeInterfaceDescriptioninterface
Interface to be implemented by any object that wishes to be notified of theServletConfig
(typically determined by theWebApplicationContext
) that it runs in.interface
Interface to be implemented by any object that wishes to be notified of theServletContext
(typically determined by theWebApplicationContext
) that it runs in. -
Uses of Aware in org.springframework.web.context.request.async
Modifier and TypeClassDescriptionclass
WebAsyncTask<V>
Holder for aCallable
, a timeout value, and a task executor. -
Uses of Aware in org.springframework.web.context.support
Modifier and TypeClassDescriptionclass
AbstractRefreshableApplicationContext
subclass which implements theConfigurableWebApplicationContext
interface for web environments.class
WebApplicationContext
implementation which accepts component classes as input — in particular@Configuration
classes, but also plain@Component
classes as well as JSR-330 compliant classes usingjakarta.inject
annotations.class
WebApplicationContext
implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by aGroovyBeanDefinitionReader
.class
Exporter that takes Spring-defined objects and exposes them as ServletContext attributes.class
FactoryBean
that fetches a specific, existing ServletContext attribute.class
FactoryBean
that retrieves a specific ServletContext init parameter (that is, a "context-param" defined inweb.xml
).class
Convenient superclass for application objects running in aWebApplicationContext
.class
WebApplicationContext
implementation which takes its configuration from XML documents, understood by anXmlBeanDefinitionReader
. -
Uses of Aware in org.springframework.web.filter
Modifier and TypeClassDescriptionclass
Base class forFilter
s that perform logging operations before and after a request is processed.class
Servlet Filter that allows one to specify a character encoding for requests.class
Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.class
Filter
to handle CORS pre-flight requests and intercept CORS simple and actual requests with aCorsProcessor
, and to update the response, e.g.class
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.class
Filter
that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.class
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
Simple base implementation ofFilter
which treats its config parameters (init-param
entries within thefilter
tag inweb.xml
) as bean properties.class
Filter
that converts posted method parameters into HTTP methods, retrievable viaHttpServletRequest.getMethod()
.class
Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.class
OverridesHttpServletResponse.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
Servlet Filter that exposes the request to the current thread, through bothLocaleContextHolder
andRequestContextHolder
.class
Filter
that createsobservations
for HTTP exchanges.class
Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.class
Filter
that generates anETag
value based on the content on the response. -
Uses of Aware in org.springframework.web.multipart.support
Modifier and TypeClassDescriptionclass
Servlet Filter that resolves multipart requests via aMultipartResolver
. -
Uses of Aware in org.springframework.web.reactive
Modifier and TypeClassDescriptionclass
Central dispatcher for HTTP request handlers/controllers. -
Uses of Aware in org.springframework.web.reactive.config
Modifier and TypeClassDescriptionclass
A subclass ofWebFluxConfigurationSupport
that detects and delegates to all beans of typeWebFluxConfigurer
allowing them to customize the configuration provided byWebFluxConfigurationSupport
.class
The main class for Spring WebFlux configuration. -
Uses of Aware in org.springframework.web.reactive.function.server.support
Modifier and TypeClassDescriptionclass
HandlerMapping
implementation that supportsRouterFunctions
. -
Uses of Aware in org.springframework.web.reactive.handler
Modifier and TypeClassDescriptionclass
Abstract base class forHandlerMapping
implementations.class
Abstract base class for URL-mappedHandlerMapping
implementations.class
Implementation of theHandlerMapping
interface to map from URLs to request handler beans. -
Uses of Aware in org.springframework.web.reactive.resource
Modifier and TypeClassDescriptionclass
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
Modifier and TypeClassDescriptionclass
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
Abstract base class for classes for whichRequestMappingInfo
defines the mapping between a request and a handler method. -
Uses of Aware in org.springframework.web.reactive.result.method.annotation
Modifier and TypeClassDescriptionclass
Supports the invocation of@RequestMapping
handler methods.class
An extension ofRequestMappingInfoHandlerMapping
that createsRequestMappingInfo
instances from class-level and method-level@RequestMapping
annotations.class
A class with an@ExceptionHandler
method that handles all Spring WebFlux raised exceptions by returning aResponseEntity
with RFC 7807 formatted error details in the body. -
Uses of Aware in org.springframework.web.reactive.result.view
Modifier and TypeClassDescriptionclass
Abstract base class for URL-based views.class
Base class forView
implementations.class
View that redirects to an absolute or context relative URL.class
AViewResolver
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
Modifier and TypeClassDescriptionclass
Configures FreeMarker for web usage via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.class
AView
implementation that uses the FreeMarker template engine.class
AViewResolver
for resolvingFreeMarkerView
instances, i.e. -
Uses of Aware in org.springframework.web.reactive.result.view.script
Modifier and TypeClassDescriptionclass
AnAbstractUrlBasedView
subclass designed to run any template library based on a JSR-223 script engine.class
Convenience subclass ofUrlBasedViewResolver
that supportsScriptTemplateView
and custom subclasses of it. -
Uses of Aware in org.springframework.web.servlet
Modifier and TypeClassDescriptionclass
Central dispatcher for HTTP request handlers/controllers, e.g.class
Base servlet for Spring's web framework.class
Simple extension ofHttpServlet
which treats its config parameters (init-param
entries within theservlet
tag inweb.xml
) as bean properties. -
Uses of Aware in org.springframework.web.servlet.config.annotation
Modifier and TypeClassDescriptionclass
A subclass ofWebMvcConfigurationSupport
that detects and delegates to all beans of typeWebMvcConfigurer
allowing them to customize the configuration provided byWebMvcConfigurationSupport
.class
This is the main class providing the configuration behind the MVC Java config. -
Uses of Aware in org.springframework.web.servlet.function.support
Modifier and TypeClassDescriptionclass
HandlerMapping
implementation that supportsRouterFunctions
. -
Uses of Aware in org.springframework.web.servlet.handler
Modifier and TypeClassDescriptionclass
Abstract implementation of theHandlerMapping
interface, detecting URL mappings for handler beans through introspection of all defined beans in the application context.class
Abstract base class forHandlerMapping
implementations.class
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
Abstract base class for URL-mappedHandlerMapping
implementations.class
Implementation of theHandlerMapping
interface that maps from URLs to beans with names that start with a slash ("/"), similar to how Struts maps URLs to action names.class
Helper class to get information from theHandlerMapping
that would serve a specific request.class
BeanPostProcessor
that applies initialization and destruction callbacks to beans that implement theServlet
interface.class
Implementation of theHandlerMapping
interface that maps from URLs to request handler beans. -
Uses of Aware in org.springframework.web.servlet.mvc
Modifier and TypeClassDescriptionclass
Convenient superclass for controller implementations, using the Template Method design pattern.class
Abstract base class forControllers
that return a view name based on the request URL.class
Trivial controller that always returns a pre-configured view and optionally sets the response status code.class
Spring Controller implementation that forwards to a named servlet, i.e.class
Spring Controller implementation that wraps a servlet instance which it manages internally.class
SimpleController
implementation that transforms the virtual path of a URL into a view name and returns that view.class
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
Modifier and TypeClassDescriptionclass
AHandlerExceptionResolver
that uses the@ResponseStatus
annotation to map exceptions to HTTP status codes. -
Uses of Aware in org.springframework.web.servlet.mvc.method
Modifier and TypeClassDescriptionclass
Abstract base class forHandlerAdapter
implementations that support handlers of typeHandlerMethod
.class
Abstract base class for classes for whichRequestMappingInfo
defines the mapping between a request and a handler method. -
Uses of Aware in org.springframework.web.servlet.mvc.method.annotation
Modifier and TypeClassDescriptionclass
AnAbstractHandlerMethodExceptionResolver
that resolves exceptions through@ExceptionHandler
methods.class
class
CreatesRequestMappingInfo
instances from type and method-level@RequestMapping
annotations in@Controller
classes.class
A class with an@ExceptionHandler
method that handles all Spring MVC raised exceptions by returning aResponseEntity
with RFC 7807 formatted error details in the body. -
Uses of Aware in org.springframework.web.servlet.resource
Modifier and TypeClassDescriptionclass
AnHttpRequestHandler
for serving static files using the Servlet container's "default" Servlet.class
HttpRequestHandler
that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.class
A filter that wraps theHttpServletResponse
and overrides itsencodeURL
method in order to translate internal resource request URLs into public URL paths for external use.class
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
Modifier and TypeClassDescriptionclass
Convenient superclass for any kind of web content generator, likeAbstractController
andWebContentInterceptor
. -
Uses of Aware in org.springframework.web.servlet.view
Modifier and TypeClassDescriptionclass
Convenient base class forViewResolver
implementations.class
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
Abstract base class for template view resolvers, in particular for FreeMarker views.class
Abstract base class for URL-based views.class
Abstract base class forView
implementations.class
A simple implementation ofViewResolver
that interprets a view name as a bean name in the current application context, i.e.class
Implementation ofViewResolver
that resolves a view based on the request file name orAccept
header.class
Wrapper for a JSP or other resource within the same web application.class
Convenient subclass ofUrlBasedViewResolver
that supportsInternalResourceView
(i.e.class
Specialization ofInternalResourceView
for JSTL pages, i.e.class
View that redirects to an absolute, context relative, or current request relative URL.class
Deprecated.as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementationsclass
Simple implementation of theViewResolver
interface, allowing for direct resolution of symbolic view names to URLs, without explicit mapping definitions.class
AViewResolver
that delegates to others.class
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
Modifier and TypeClassDescriptionclass
Abstract superclass for PDF views that operate on an existing document with an AcroForm.class
Abstract superclass for PDF views.class
Convenient superclass for Excel document views in traditional XLS format.class
Convenient superclass for Excel document views in the Office 2007 XLSX format, using POI's streaming variant.class
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
Modifier and TypeClassDescriptionclass
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
Abstract superclass for RSS Feed views, using the ROME package. -
Uses of Aware in org.springframework.web.servlet.view.freemarker
Modifier and TypeClassDescriptionclass
JavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.class
View using the FreeMarker template engine.class
Convenience subclass ofUrlBasedViewResolver
that supportsFreeMarkerView
(i.e. -
Uses of Aware in org.springframework.web.servlet.view.groovy
Modifier and TypeClassDescriptionclass
An extension of Groovy'sTemplateConfiguration
and an implementation of Spring MVC'sGroovyMarkupConfig
for creating aMarkupTemplateEngine
for use in a web application.class
AnAbstractTemplateView
subclass based on Groovy XML/XHTML markup templates.class
Convenience subclass ofAbstractTemplateViewResolver
that supportsGroovyMarkupView
(i.e. -
Uses of Aware in org.springframework.web.servlet.view.json
Modifier and TypeClassDescriptionclass
Abstract base class for Jackson based and content type independentAbstractView
implementations.class
Spring MVCView
that renders JSON content by serializing the model for the current request using Jackson 2'sObjectMapper
. -
Uses of Aware in org.springframework.web.servlet.view.script
Modifier and TypeClassDescriptionclass
AnAbstractUrlBasedView
subclass designed to run any template library based on a JSR-223 script engine.class
Convenience subclass ofUrlBasedViewResolver
that supportsScriptTemplateView
and custom subclasses of it. -
Uses of Aware in org.springframework.web.servlet.view.xml
Modifier and TypeClassDescriptionclass
Spring MVCView
that renders XML content by serializing the model for the current request using Jackson 2'sXmlMapper
.class
Spring-MVCView
that allows for response context to be rendered as the result of marshalling by aMarshaller
. -
Uses of Aware in org.springframework.web.servlet.view.xslt
Modifier and TypeClassDescriptionclass
XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation.class
ViewResolver
implementation that resolves instances ofXsltView
by translating the supplied view name into the URL of the XSLT stylesheet. -
Uses of Aware in org.springframework.web.socket.client.standard
Modifier and TypeClassDescriptionclass
WebSocketconnection manager
that connects to the server viaWebSocketContainer
and handles the session with an@ClientEndpoint
endpoint.class
WebSocketconnection manager
that connects to the server viaWebSocketContainer
and handles the session with anEndpoint
. -
Uses of Aware in org.springframework.web.socket.config.annotation
Modifier and TypeClassDescriptionclass
AWebSocketMessageBrokerConfigurationSupport
extension that detects beans of typeWebSocketMessageBrokerConfigurer
and delegates to all of them allowing callback style customization of the configuration provided inWebSocketMessageBrokerConfigurationSupport
.class
ExtendsAbstractMessageBrokerConfiguration
and adds configuration for receiving and responding to STOMP messages from WebSocket clients. -
Uses of Aware in org.springframework.web.socket.handler
Modifier and TypeClassDescriptionclass
Instantiates a target handler through a SpringBeanFactory
and also provides an equivalent destroy method.class
AWebSocketHandler
that initializes and destroys aWebSocketHandler
instance for each WebSocket connection and delegates all other methods to it. -
Uses of Aware in org.springframework.web.socket.messaging
Modifier and TypeClassDescriptionclass
ASubProtocolHandler
for STOMP that supports versions 1.0, 1.1, and 1.2 of the STOMP specification.class
A subclass ofSimpAnnotationMethodMessageHandler
to provide support forControllerAdvice
with global@MessageExceptionHandler
methods. -
Uses of Aware in org.springframework.web.socket.server.standard
Modifier and TypeClassDescriptionclass
Detects beans of typeServerEndpointConfig
and registers with the standard Java WebSocket runtime.class
An implementation ofServerEndpointConfig
for use in Spring-based applications.class
AFactoryBean
for configuringServerContainer
. -
Uses of Aware in org.springframework.web.socket.server.support
Modifier and TypeClassDescriptionclass
A defaultHandshakeHandler
implementation, extendingAbstractHandshakeHandler
with Servlet-specific initialization support.class
Extension ofSimpleUrlHandlerMapping
with support for more precise mapping of WebSocket handshake requests to handlers of typeWebSocketHttpRequestHandler
.class
AHttpRequestHandler
for processing WebSocket handshake requests. -
Uses of Aware in org.springframework.web.socket.sockjs.support
Modifier and TypeClassDescriptionclass
AnHttpRequestHandler
that allows mapping aSockJsService
to requests in a Servlet container. -
Uses of Aware in org.springframework.web.socket.sockjs.transport.handler
Modifier and TypeClassDescriptionclass
A default implementation ofSockJsService
with all defaultTransportHandler
implementations pre-registered.class
WebSocket-basedTransportHandler
.
PropertyPlaceholderConfigurer