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.interceptor |
Provides miscellaneous interceptor implementations.
|
org.springframework.aop.support |
Convenience classes for using Spring's AOP API.
|
org.springframework.beans |
This package contains interfaces and classes for manipulating Java beans.
|
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.cache.interceptor |
AOP-based solution for declarative caching demarcation.
|
org.springframework.cache.jcache.interceptor |
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
|
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.core |
Provides basic classes for exception handling and version detection,
and other core helpers that are not specific to any part of the framework.
|
org.springframework.dao.annotation |
Annotation support for DAOs.
|
org.springframework.jms.annotation |
Annotations and support classes for declarative JMS listener endpoints.
|
org.springframework.messaging.handler |
Basic abstractions for working with message handler methods.
|
org.springframework.messaging.simp.user |
Support for handling messages to "user" destinations (i.e.
|
org.springframework.orm.hibernate5 |
Package providing integration of
Hibernate 5.x
with Spring concepts.
|
org.springframework.orm.jpa.support |
Classes supporting the
org.springframework.orm.jpa package. |
org.springframework.scheduling.annotation |
Java 5 annotation for asynchronous method execution.
|
org.springframework.scripting.support |
Support classes for Spring's scripting package.
|
org.springframework.test.context.event |
Test event support classes for the Spring TestContext Framework.
|
org.springframework.test.context.jdbc |
JDBC support classes for the Spring TestContext Framework,
including support for declarative SQL script execution via
@Sql . |
org.springframework.test.context.support |
Support classes for the Spring TestContext Framework.
|
org.springframework.test.context.transaction |
Transactional support classes for the Spring TestContext Framework.
|
org.springframework.test.context.web |
Web support classes for the Spring TestContext Framework.
|
org.springframework.transaction.event |
Spring's support for listening to transaction events.
|
org.springframework.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
|
org.springframework.transaction.support |
Support classes for the org.springframework.transaction package.
|
org.springframework.validation.beanvalidation |
Support classes for integrating a JSR-303 Bean Validation provider
(such as Hibernate Validator) into a Spring ApplicationContext
and in particular with Spring's data binding and validation APIs.
|
org.springframework.web.method |
Common infrastructure for handler method processing, as used by
Spring MVC's
org.springframework.web.servlet.mvc.method package. |
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.result |
Support for various programming model styles including the invocation of
different types of handlers, e.g.
|
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.reactive.socket.server.support |
Server-side support classes for WebSocket requests.
|
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.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.mvc.support |
Support package for MVC controllers.
|
org.springframework.web.servlet.view |
Provides standard View and ViewResolver implementations,
including abstract base classes for custom implementations.
|
org.springframework.web.servlet.view.groovy |
Support classes for the integration of
Groovy Templates as Spring web view technology.
|
org.springframework.web.servlet.view.tiles3 |
Support classes for the integration of
Tiles 3
(the standalone version of Tiles) as Spring web view technology.
|
org.springframework.web.servlet.view.xslt |
Support classes for XSLT,
providing a View implementation for XSLT stylesheets.
|
org.springframework.web.socket.messaging |
WebSocket integration for Spring's messaging module.
|
org.springframework.web.socket.server.support |
Server-side support classes including container-specific strategies
for upgrading a request.
|
Modifier and Type | Interface and Description |
---|---|
interface |
AspectInstanceFactory
Interface implemented to provide an instance of an AspectJ aspect.
|
interface |
AspectJPrecedenceInformation
Interface to be implemented by types that can supply the information
needed to sort advice/advisors by AspectJ's precedence rules.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractAspectJAdvice
Base class for AOP Alliance
Advice classes
wrapping an AspectJ aspect or an AspectJ-annotated advice method. |
class |
AspectJAfterAdvice
Spring AOP advice wrapping an AspectJ after advice method.
|
class |
AspectJAfterReturningAdvice
Spring AOP advice wrapping an AspectJ after-returning advice method.
|
class |
AspectJAfterThrowingAdvice
Spring AOP advice wrapping an AspectJ after-throwing advice method.
|
class |
AspectJAroundAdvice
Spring AOP around advice (MethodInterceptor) that wraps
an AspectJ advice method.
|
class |
AspectJExpressionPointcutAdvisor
Spring AOP Advisor that can be used for any AspectJ pointcut expression.
|
class |
AspectJMethodBeforeAdvice
Spring AOP advice that wraps an AspectJ before method.
|
class |
AspectJPointcutAdvisor
AspectJPointcutAdvisor that adapts an
AbstractAspectJAdvice
to the PointcutAdvisor interface. |
class |
SimpleAspectInstanceFactory
Implementation of
AspectInstanceFactory that creates a new instance
of the specified aspect class for every SimpleAspectInstanceFactory.getAspectInstance() call. |
class |
SingletonAspectInstanceFactory
Implementation of
AspectInstanceFactory that is backed by a
specified singleton object, returning the same instance for every
SingletonAspectInstanceFactory.getAspectInstance() call. |
Modifier and Type | Interface and Description |
---|---|
interface |
MetadataAwareAspectInstanceFactory
Subinterface of
AspectInstanceFactory
that returns AspectMetadata associated with AspectJ-annotated classes. |
Modifier and Type | Class and Description |
---|---|
class |
AnnotationAwareAspectJAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ
annotation aspects in the current application context, as well as Spring Advisors. |
class |
BeanFactoryAspectInstanceFactory
AspectInstanceFactory implementation
backed by a Spring BeanFactory . |
class |
LazySingletonAspectInstanceFactoryDecorator
Decorator to cause a
MetadataAwareAspectInstanceFactory to instantiate only once. |
class |
PrototypeAspectInstanceFactory
AspectInstanceFactory backed by a
BeanFactory -provided prototype, enforcing prototype semantics. |
protected static class |
ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor
Synthetic advisor that instantiates the aspect.
|
class |
SimpleMetadataAwareAspectInstanceFactory
Implementation of
MetadataAwareAspectInstanceFactory that
creates a new instance of the specified aspect class for every
SimpleAspectInstanceFactory.getAspectInstance() call. |
class |
SingletonMetadataAwareAspectInstanceFactory
Implementation of
MetadataAwareAspectInstanceFactory that is backed
by a specified singleton object, returning the same instance for every
SingletonAspectInstanceFactory.getAspectInstance() call. |
Modifier and Type | Class and Description |
---|---|
class |
AspectJAwareAdvisorAutoProxyCreator
AbstractAdvisorAutoProxyCreator
subclass that exposes AspectJ's invocation context and understands AspectJ's rules
for advice precedence when multiple pieces of advice come from the same aspect. |
Modifier and Type | Class and Description |
---|---|
class |
SimpleBeanFactoryAwareAspectInstanceFactory
Implementation of
AspectInstanceFactory that locates the aspect from the
BeanFactory using a configured bean name. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractAdvisingBeanPostProcessor
Base class for
BeanPostProcessor implementations that apply a
Spring AOP Advisor to specific beans. |
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. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractAdvisorAutoProxyCreator
Generic auto proxy creator that builds AOP proxies for specific beans
based on detected Advisors for each bean.
|
class |
AbstractAutoProxyCreator
BeanPostProcessor implementation
that wraps each eligible bean with an AOP proxy, delegating to specified interceptors
before invoking the bean itself. |
class |
AbstractBeanFactoryAwareAdvisingPostProcessor
Extension of
AbstractAutoProxyCreator which implements BeanFactoryAware ,
adds exposure of the original target class for each proxied bean
(AutoProxyUtils.ORIGINAL_TARGET_CLASS_ATTRIBUTE ),
and participates in an externally enforced target-class mode for any given bean
(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE ). |
class |
BeanNameAutoProxyCreator
Auto proxy creator that identifies beans to proxy via a list of names.
|
class |
DefaultAdvisorAutoProxyCreator
BeanPostProcessor implementation that creates AOP proxies based on all
candidate Advisor s in the current BeanFactory . |
class |
InfrastructureAdvisorAutoProxyCreator
Auto-proxy creator that considers infrastructure Advisor beans only,
ignoring any application-defined Advisors.
|
Modifier and Type | Class and Description |
---|---|
class |
AsyncExecutionInterceptor
AOP Alliance
MethodInterceptor that processes method invocations
asynchronously, using a given AsyncTaskExecutor . |
class |
ExposeInvocationInterceptor
Interceptor that exposes the current
MethodInvocation
as a thread-local object. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractBeanFactoryPointcutAdvisor
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in a BeanFactory.
|
class |
AbstractGenericPointcutAdvisor
Abstract generic
PointcutAdvisor
that allows for any Advice to be configured. |
class |
AbstractPointcutAdvisor
Abstract base class for
PointcutAdvisor
implementations. |
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.
|
class |
DefaultIntroductionAdvisor
Simple
IntroductionAdvisor implementation
that by default applies to any class. |
class |
DefaultPointcutAdvisor
Convenient Pointcut-driven Advisor implementation.
|
class |
NameMatchMethodPointcutAdvisor
Convenient class for name-match method pointcuts that hold an Advice,
making them an Advisor.
|
class |
RegexpMethodPointcutAdvisor
Convenient class for regexp method pointcuts that hold an Advice,
making them an
Advisor . |
class |
StaticMethodMatcherPointcutAdvisor
Convenient base class for Advisors that are also static pointcuts.
|
Modifier and Type | Class and Description |
---|---|
class |
ExtendedBeanInfoFactory
BeanInfoFactory implementation that evaluates whether bean classes have
"non-standard" JavaBeans setter methods and are thus candidates for introspection
by Spring's (package-visible) ExtendedBeanInfo implementation. |
Modifier and Type | Class and Description |
---|---|
class |
AutowiredAnnotationBeanPostProcessor
BeanPostProcessor
implementation that autowires annotated fields, setter methods, and arbitrary
config methods. |
class |
CustomAutowireConfigurer
A
BeanFactoryPostProcessor
implementation that allows for convenient registration of custom autowire
qualifier types. |
class |
InitDestroyAnnotationBeanPostProcessor
BeanPostProcessor implementation
that invokes annotated init and destroy methods. |
class |
RequiredAnnotationBeanPostProcessor
Deprecated.
as of 5.1, in favor of using constructor injection for required settings
(or a custom
InitializingBean implementation) |
Modifier and Type | Class and Description |
---|---|
class |
CustomEditorConfigurer
BeanFactoryPostProcessor implementation that allows for convenient
registration of custom property editors . |
class |
CustomScopeConfigurer
Simple
BeanFactoryPostProcessor implementation that registers
custom Scope(s) with the containing ConfigurableBeanFactory . |
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 |
PropertyOverrideConfigurer
Property resource configurer that overrides bean property values in an application
context definition.
|
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 |
PropertyResourceConfigurer
Allows for configuration of individual bean property values from a property resource,
i.e.
|
Modifier and Type | Class and Description |
---|---|
class |
BeanFactoryCacheOperationSourceAdvisor
Advisor driven by a
CacheOperationSource , used to include a
cache advice bean for methods that are cacheable. |
Modifier and Type | Class and Description |
---|---|
class |
BeanFactoryJCacheOperationSourceAdvisor
Advisor driven by a
JCacheOperationSource , used to include a
cache advice bean for methods that are cacheable. |
Modifier and Type | Class and Description |
---|---|
class |
CommonAnnotationBeanPostProcessor
BeanPostProcessor implementation
that supports common Java annotations out of the box, in particular the JSR-250
annotations in the javax.annotation package. |
class |
ConfigurationClassPostProcessor
BeanFactoryPostProcessor used for bootstrapping processing of
@Configuration classes. |
Modifier and Type | Interface and Description |
---|---|
interface |
GenericApplicationListener
Extended variant of the standard
ApplicationListener interface,
exposing further metadata such as the supported event and source type. |
interface |
SmartApplicationListener
Extended variant of the standard
ApplicationListener interface,
exposing further metadata such as the supported event and source type. |
Modifier and Type | Class and Description |
---|---|
class |
ApplicationListenerMethodAdapter
GenericApplicationListener adapter that delegates the processing of
an event to an EventListener annotated method. |
class |
DefaultEventListenerFactory
Default
EventListenerFactory implementation that supports the
regular EventListener annotation. |
class |
GenericApplicationListenerAdapter
GenericApplicationListener adapter that determines supported event types
through introspecting the generically declared type of the target listener. |
class |
SourceFilteringListener
ApplicationListener decorator that filters
events from a specified event source, invoking its delegate listener for
matching ApplicationEvent objects only. |
Modifier and Type | Class and Description |
---|---|
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 . |
Modifier and Type | Class and Description |
---|---|
class |
AspectJWeavingEnabler
Post-processor that registers AspectJ's
ClassPreProcessorAgentAdapter
with the Spring application context's default
LoadTimeWeaver . |
Modifier and Type | Interface and Description |
---|---|
interface |
PriorityOrdered
|
Modifier and Type | Class and Description |
---|---|
class |
PersistenceExceptionTranslationAdvisor
Spring AOP exception translation aspect for use at Repository or DAO layer level.
|
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). |
Modifier and Type | Class and Description |
---|---|
class |
JmsListenerAnnotationBeanPostProcessor
Bean post-processor that registers methods annotated with
JmsListener
to be invoked by a JMS message listener container created under the cover
by a JmsListenerContainerFactory
according to the attributes of the annotation. |
Modifier and Type | Interface and Description |
---|---|
interface |
MessagingAdviceBean
Represents a Spring-managed bean with cross-cutting functionality to be
applied to one or more Spring beans with annotation-based message
handling methods.
|
Modifier and Type | Class and Description |
---|---|
class |
MultiServerUserRegistry
SimpUserRegistry that looks up users in a "local" user registry as
well as a set of "remote" user registries. |
Modifier and Type | Class and Description |
---|---|
class |
SpringFlushSynchronization
Simple synchronization adapter that propagates a
flush() call
to the underlying Hibernate Session. |
class |
SpringSessionSynchronization
Callback for resource cleanup at the end of a Spring-managed transaction
for a pre-bound Hibernate Session.
|
Modifier and Type | Class and Description |
---|---|
class |
PersistenceAnnotationBeanPostProcessor
BeanPostProcessor that processes
PersistenceUnit
and PersistenceContext annotations, for injection of
the corresponding JPA resources EntityManagerFactory
and EntityManager . |
Modifier and Type | Class and Description |
---|---|
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 of the target's interfaces). |
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. |
Modifier and Type | Class and Description |
---|---|
class |
ScriptFactoryPostProcessor
BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it. |
Modifier and Type | Class and Description |
---|---|
class |
ApplicationEventsTestExecutionListener
TestExecutionListener which provides support for ApplicationEvents . |
class |
EventPublishingTestExecutionListener
TestExecutionListener
that publishes test execution events to the
ApplicationContext
for the currently executing test. |
Modifier and Type | Class and Description |
---|---|
class |
SqlScriptsTestExecutionListener
TestExecutionListener that provides support for executing SQL
scripts and inlined statements
configured via the @Sql annotation. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractDirtiesContextTestExecutionListener
Abstract base class for
TestExecutionListener implementations that
provide support for marking the ApplicationContext associated with
a test as dirty for both test classes and test methods annotated
with the @DirtiesContext annotation. |
class |
AbstractTestExecutionListener
Abstract ordered implementation of the
TestExecutionListener API. |
class |
DependencyInjectionTestExecutionListener
TestExecutionListener which provides support for dependency
injection and initialization of test instances. |
class |
DirtiesContextBeforeModesTestExecutionListener
TestExecutionListener which provides support for marking the
ApplicationContext associated with a test as dirty for
both test classes and test methods annotated with the
@DirtiesContext annotation. |
class |
DirtiesContextTestExecutionListener
TestExecutionListener which provides support for marking the
ApplicationContext associated with a test as dirty for
both test classes and test methods annotated with the
@DirtiesContext annotation. |
Modifier and Type | Class and Description |
---|---|
class |
TransactionalTestExecutionListener
TestExecutionListener that provides support for executing tests
within test-managed transactions by honoring Spring's
@Transactional annotation. |
Modifier and Type | Class and Description |
---|---|
class |
ServletTestExecutionListener
TestExecutionListener which provides mock Servlet API support to
WebApplicationContexts loaded by the Spring
TestContext Framework. |
Modifier and Type | Interface and Description |
---|---|
interface |
TransactionalApplicationListener<E extends ApplicationEvent>
An
ApplicationListener that is invoked according to a TransactionPhase . |
Modifier and Type | Class and Description |
---|---|
class |
TransactionalApplicationListenerAdapter<E extends ApplicationEvent>
TransactionalApplicationListener adapter that delegates the processing of
an event to a target ApplicationListener instance. |
class |
TransactionalApplicationListenerMethodAdapter
GenericApplicationListener adapter that delegates the processing of
an event to a TransactionalEventListener annotated method. |
class |
TransactionalEventListenerFactory
EventListenerFactory implementation that handles TransactionalEventListener
annotated methods. |
Modifier and Type | Class and Description |
---|---|
class |
BeanFactoryTransactionAttributeSourceAdvisor
Advisor driven by a
TransactionAttributeSource , used to include
a transaction advice bean for methods that are transactional. |
class |
TransactionAttributeSourceAdvisor
Advisor driven by a
TransactionAttributeSource , used to include
a TransactionInterceptor only for methods that are transactional. |
Modifier and Type | Interface and Description |
---|---|
interface |
TransactionSynchronization
Interface for transaction synchronization callbacks.
|
Modifier and Type | Class and Description |
---|---|
class |
ResourceHolderSynchronization<H extends ResourceHolder,K>
TransactionSynchronization implementation that manages a
ResourceHolder bound through TransactionSynchronizationManager . |
class |
TransactionSynchronizationAdapter
Deprecated.
as of 5.3, in favor of the default methods on the
TransactionSynchronization interface |
Modifier and Type | Class and Description |
---|---|
class |
MethodValidationPostProcessor
A convenient
BeanPostProcessor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods. |
Modifier and Type | Class and Description |
---|---|
class |
ControllerAdviceBean
Encapsulates information about an
@ControllerAdvice
Spring-managed bean without necessarily requiring it to be instantiated. |
Modifier and Type | Class and Description |
---|---|
class |
RouterFunctionMapping
HandlerMapping implementation that supports RouterFunctions . |
class |
ServerResponseResultHandler
HandlerResultHandler implementation that supports ServerResponses . |
Modifier and Type | Class and Description |
---|---|
class |
AbstractHandlerMapping
Abstract base class for
HandlerMapping
implementations. |
class |
AbstractUrlHandlerMapping
Abstract base class for URL-mapped
HandlerMapping implementations. |
class |
SimpleUrlHandlerMapping
Implementation of the
HandlerMapping
interface to map from URLs to request handler beans. |
Modifier and Type | Class and Description |
---|---|
class |
HandlerResultHandlerSupport
Base class for
HandlerResultHandler with support for content negotiation and access to a
ReactiveAdapter registry. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractHandlerMethodMapping<T>
Abstract base class for
HandlerMapping implementations that define
a mapping between a request and a HandlerMethod . |
class |
RequestMappingInfoHandlerMapping
Abstract base class for classes for which
RequestMappingInfo defines
the mapping between a request and a handler method. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractMessageWriterResultHandler
Abstract base class for result handlers that handle return values by writing
to the response with
HttpMessageWriter . |
class |
RequestMappingHandlerMapping
An extension of
RequestMappingInfoHandlerMapping that creates
RequestMappingInfo instances from class-level and method-level
@RequestMapping annotations. |
class |
ResponseBodyResultHandler
HandlerResultHandler that handles return values from methods annotated
with @ResponseBody writing to the body of the request or response with
an HttpMessageWriter . |
class |
ResponseEntityResultHandler
Handles
HttpEntity and ResponseEntity return values. |
Modifier and Type | Class and Description |
---|---|
class |
UrlBasedViewResolver
A
ViewResolver that allows direct resolution of symbolic view names
to URLs without explicit mapping definitions. |
class |
ViewResolutionResultHandler
HandlerResultHandler that encapsulates the view resolution algorithm
supporting the following return types:
Void or no value -- default view name
String -- view name unless @ModelAttribute -annotated
View -- View to render with
Model -- attributes to add to the model
Map -- attributes to add to the model
Rendering -- use case driven API for view resolution
@ModelAttribute -- attribute for the model
Non-simple value -- attribute for the model
|
class |
ViewResolverSupport
Base class for
ViewResolver implementations with shared properties. |
Modifier and Type | Class and Description |
---|---|
class |
FreeMarkerViewResolver
A
ViewResolver for resolving FreeMarkerView instances, i.e. |
Modifier and Type | Class and Description |
---|---|
class |
ScriptTemplateViewResolver
Convenience subclass of
UrlBasedViewResolver that supports
ScriptTemplateView and custom subclasses of it. |
Modifier and Type | Class and Description |
---|---|
class |
WebSocketHandlerAdapter
HandlerAdapter that allows
DispatcherHandler to support
handlers of type WebSocketHandler with such handlers mapped to
URL patterns via
SimpleUrlHandlerMapping . |
Modifier and Type | Class and Description |
---|---|
class |
HandlerFunctionAdapter
HandlerAdapter implementation that supports HandlerFunction s. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractDetectingUrlHandlerMapping
Abstract implementation of the
HandlerMapping
interface, detecting URL mappings for handler beans through introspection of all
defined beans in the application context. |
class |
AbstractHandlerExceptionResolver
Abstract base class for
HandlerExceptionResolver implementations. |
class |
AbstractHandlerMethodExceptionResolver
Abstract base class for
HandlerExceptionResolver
implementations that support handling exceptions from handlers of type HandlerMethod . |
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 |
HandlerExceptionResolverComposite
A
HandlerExceptionResolver that delegates to a list of other
HandlerExceptionResolvers . |
class |
SimpleMappingExceptionResolver
HandlerExceptionResolver implementation
that allows for mapping exception class names to view names, either for a set of
given handlers or for all handlers in the DispatcherServlet. |
Modifier and Type | Class and Description |
---|---|
class |
ResponseStatusExceptionResolver
A
HandlerExceptionResolver that uses the @ResponseStatus
annotation to map exceptions to HTTP status codes. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractHandlerMethodAdapter
Abstract base class for
HandlerAdapter implementations that support
handlers of type HandlerMethod . |
Modifier and Type | Class and Description |
---|---|
class |
ExceptionHandlerExceptionResolver
An
AbstractHandlerMethodExceptionResolver that resolves exceptions
through @ExceptionHandler methods. |
class |
RequestMappingHandlerAdapter
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultHandlerExceptionResolver
The default implementation of the
HandlerExceptionResolver
interface, resolving standard Spring MVC exceptions and translating them to corresponding
HTTP status codes. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractTemplateViewResolver
Abstract base class for template view resolvers, in particular for FreeMarker views.
|
class |
BeanNameViewResolver
A simple implementation of
ViewResolver
that interprets a view name as a bean name in the current application context,
i.e. |
class |
ContentNegotiatingViewResolver
Implementation of
ViewResolver that resolves a view based on the request file name
or Accept header. |
class |
InternalResourceViewResolver
Convenient subclass of
UrlBasedViewResolver that supports
InternalResourceView (i.e. |
class |
ResourceBundleViewResolver
Deprecated.
as of 5.3, in favor of Spring's common view resolver variants
and/or custom resolver implementations
|
class |
ViewResolverComposite
A
ViewResolver that delegates to others. |
class |
XmlViewResolver
Deprecated.
as of 5.3, in favor of Spring's common view resolver variants
and/or custom resolver implementations
|
Modifier and Type | Class and Description |
---|---|
class |
GroovyMarkupViewResolver
Convenience subclass of
AbstractTemplateViewResolver that supports
GroovyMarkupView (i.e. |
Modifier and Type | Class and Description |
---|---|
class |
TilesViewResolver
Convenience subclass of
UrlBasedViewResolver that supports
TilesView (i.e. |
Modifier and Type | Class and Description |
---|---|
class |
XsltViewResolver
ViewResolver implementation that
resolves instances of XsltView by translating the supplied view name
into the URL of the XSLT stylesheet. |
Modifier and Type | Class and Description |
---|---|
class |
DefaultSimpUserRegistry
A default implementation of
SimpUserRegistry that relies on
AbstractSubProtocolEvent application context events to keep
track of connected users and their subscriptions. |
Modifier and Type | Class and Description |
---|---|
class |
WebSocketHandlerMapping
Extension of
SimpleUrlHandlerMapping with support for more
precise mapping of WebSocket handshake requests to handlers of type
WebSocketHttpRequestHandler . |