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.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.jdbc.support.lob |
Provides a stategy interface for Large OBject handling,
with implementations for various databases.
|
org.springframework.orm.jpa.support |
Classes supporting the
org.springframework.orm.jpa package. |
org.springframework.scheduling.annotation |
JDK 1.5+ annotation for asynchronous method execution.
|
org.springframework.scripting.support |
Support classes for Spring's scripting package.
|
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 4.0) into a Spring ApplicationContext
and in particular with Spring's data binding and validation APIs.
|
org.springframework.web.context.support |
Classes supporting the
org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
org.springframework.web.method |
Common infrastructure for handler method processing, as used by
Spring MVC's
org.springframework.web.servlet.mvc.method package. |
org.springframework.web.portlet.handler |
Provides standard HandlerMapping implementations,
including abstract base classes for custom implementations.
|
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.freemarker |
Support classes for the integration of
FreeMarker
as Spring web view technology.
|
org.springframework.web.servlet.view.jasperreports |
Support classes for the integration of
JasperReports
as Spring web view technology.
|
org.springframework.web.servlet.view.tiles2 |
Support classes for the integration of
Tiles2
(the standalone version of Tiles) as Spring web view technology.
|
org.springframework.web.servlet.view.velocity |
Support classes for the integration of
Velocity
as Spring web view technology.
|
org.springframework.web.servlet.view.xslt |
Support classes for XSLT,
providing a View implementation for XSLT stylesheets.
|
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. |
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 |
BeanNameAutoProxyCreator
Auto proxy creator that identifies beans to proxy via a list of names.
|
class |
DefaultAdvisorAutoProxyCreator
BeanPostProcessor implementation that creates AOP proxies based on all candidate
Advisors in the current BeanFactory.
|
class |
InfrastructureAdvisorAutoProxyCreator
Auto-proxy creator that considers infrastructure Advisor beans only,
ignoring any application-defined Advisors.
|
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
BeanPostProcessor implementation
that enforces required JavaBean properties to have been configured. |
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
Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's
Preferences API (
java.util.prefs ). |
class |
PropertyOverrideConfigurer
Property resource configurer that overrides bean property values in an application
context definition.
|
class |
PropertyPlaceholderConfigurer
PlaceholderConfigurerSupport subclass that resolves ${...} placeholders
against local properties and/or system properties
and environment variables. |
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 |
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 |
SmartApplicationListener
Extended variant of the standard
ApplicationListener interface,
exposing further metadata such as the supported event type. |
Modifier and Type | Class and Description |
---|---|
class |
GenericApplicationListenerAdapter
SmartApplicationListener 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
Extension of the
Ordered interface, expressing a 'priority'
ordering: Order values expressed by PriorityOrdered objects always
apply before order values of 'plain' Ordered values. |
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 |
SpringLobCreatorSynchronization
Callback for resource cleanup at the end of a Spring transaction.
|
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 |
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 | Class and Description |
---|---|
class |
TransactionSynchronizationAdapter
Simple
TransactionSynchronization adapter containing empty
method implementations, for easier overriding of single methods. |
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 |
ServletContextPropertyPlaceholderConfigurer
Deprecated.
in Spring 3.1 in favor of
PropertySourcesPlaceholderConfigurer
in conjunction with StandardServletEnvironment . |
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 |
AbstractMapBasedHandlerMapping<K>
Abstract base class for
HandlerMapping
implementations that rely on a map which caches handler objects per lookup key. |
class |
ParameterHandlerMapping
Implementation of the
HandlerMapping
to map from a request parameter to request handler beans. |
class |
PortletModeHandlerMapping
Implementation of the
HandlerMapping
interface to map from the current PortletMode to request handler beans. |
class |
PortletModeParameterHandlerMapping
Implementation of the
HandlerMapping
interface to map from the current PortletMode and a request parameter to
request handler beans. |
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 |
AbstractHandlerMapping
Abstract base class for
HandlerMapping
implementations. |
class |
AbstractHandlerMethodExceptionResolver
Abstract base class for
HandlerExceptionResolver
implementations that support handling exceptions from handlers of type HandlerMethod . |
class |
AbstractHandlerMethodMapping<T>
Abstract base class for
HandlerMapping implementations that define a
mapping between a request and a HandlerMethod . |
class |
AbstractUrlHandlerMapping
Abstract base class for URL-mapped
HandlerMapping
implementations. |
class |
BeanNameUrlHandlerMapping
Implementation of the
HandlerMapping
interface that map 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 HandlerExceptionResolver s. |
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. |
class |
SimpleUrlHandlerMapping
Implementation of the
HandlerMapping
interface to map from URLs to request handler beans. |
Modifier and Type | Class and Description |
---|---|
class |
AnnotationMethodHandlerAdapter
Deprecated.
in Spring 3.2 in favor of
RequestMappingHandlerAdapter |
class |
AnnotationMethodHandlerExceptionResolver
Deprecated.
as of Spring 3.2, in favor of
ExceptionHandlerExceptionResolver |
class |
DefaultAnnotationHandlerMapping
Deprecated.
in Spring 3.2 in favor of
RequestMappingHandlerMapping |
class |
ResponseStatusExceptionResolver
Implementation of the
HandlerExceptionResolver
interface 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 . |
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 |
ExceptionHandlerExceptionResolver
An
AbstractHandlerMethodExceptionResolver that resolves exceptions
through @ExceptionHandler methods. |
class |
RequestMappingHandlerAdapter
An
AbstractHandlerMethodAdapter that supports HandlerMethod s
with the signature -- method argument and return types, defined in
@RequestMapping . |
class |
RequestMappingHandlerMapping
Creates
RequestMappingInfo instances from type and method-level
@RequestMapping annotations in
@Controller classes. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractControllerUrlHandlerMapping
Base class for
HandlerMapping implementations
that derive URL paths according to conventions for specific controller types. |
class |
ControllerBeanNameHandlerMapping
Implementation of
HandlerMapping that
follows a simple convention for generating URL path mappings from the bean names
of registered Controller beans
as well as @Controller annotated beans. |
class |
ControllerClassNameHandlerMapping
Implementation of
HandlerMapping that
follows a simple convention for generating URL path mappings from the class names
of registered Controller beans
as well as @Controller annotated beans. |
class |
DefaultHandlerExceptionResolver
Default implementation of the
HandlerExceptionResolver interface that resolves standard Spring exceptions and translates
them to corresponding HTTP status codes. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractTemplateViewResolver
Abstract base class for template view resolvers,
in particular for Velocity and 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
A
ViewResolver implementation that uses
bean definitions in a ResourceBundle , specified by the bundle basename. |
class |
UrlBasedViewResolver
Simple implementation of the
ViewResolver
interface, allowing for direct resolution of symbolic view names to URLs,
without explicit mapping definition. |
class |
XmlViewResolver
A
ViewResolver implementation that uses
bean definitions in a dedicated XML file for view definitions, specified by
resource location. |
Modifier and Type | Class and Description |
---|---|
class |
FreeMarkerViewResolver
Convenience subclass of
UrlBasedViewResolver
that supports FreeMarkerView (i.e. |
Modifier and Type | Class and Description |
---|---|
class |
JasperReportsViewResolver
ViewResolver implementation that
resolves instances of AbstractJasperReportsView by translating
the supplied view name into the URL of the report file. |
Modifier and Type | Class and Description |
---|---|
class |
TilesViewResolver
Convenience subclass of
UrlBasedViewResolver
that supports TilesView (i.e. |
Modifier and Type | Class and Description |
---|---|
class |
VelocityLayoutViewResolver
Convenience subclass of VelocityViewResolver, adding support
for VelocityLayoutView and its properties.
|
class |
VelocityViewResolver
Convenience subclass of
UrlBasedViewResolver
that supports VelocityView (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. |
Copyright © 2015. All rights reserved.