| Package | Description |
|---|---|
| org.springframework.aop.aspectj |
AspectJ integration package.
|
| org.springframework.aop.aspectj.annotation |
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
|
| org.springframework.aop.aspectj.autoproxy |
Base classes enabling auto-proxying based on AspectJ.
|
| org.springframework.aop.config |
Support package for declarative AOP configuration,
with XML schema being the primary configuration format.
|
| org.springframework.aop.framework |
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
|
| org.springframework.aop.framework.autoproxy |
Bean post-processors for use in ApplicationContexts to simplify AOP usage
by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
|
| org.springframework.aop.framework.autoproxy.target |
Generic support classes for target source creation.
|
| org.springframework.aop.interceptor |
Provides miscellaneous interceptor implementations.
|
| org.springframework.aop.scope |
Support for AOP-based scoping of target objects, with configurable backend.
|
| org.springframework.aop.support |
Convenience classes for using Spring's AOP API.
|
| org.springframework.aop.target |
This package contains implementations of the org.springframework.aop.TargetSource interface.
|
| org.springframework.beans.factory.annotation |
Support package for annotation-driven bean configuration.
|
| org.springframework.beans.factory.config |
SPI interfaces and configuration-related convenience classes for bean factories.
|
| org.springframework.beans.factory.serviceloader |
Support package for the JDK 1.6 ServiceLoader facility.
|
| org.springframework.beans.factory.wiring |
Mechanism to determine bean wiring metadata from a bean instance.
|
| 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.dao.annotation |
Annotation support for DAOs.
|
| org.springframework.dao.support |
Support classes for DAO implementations,
providing miscellaneous utility methods.
|
| org.springframework.jdbc.config |
Defines the Spring JDBC configuration namespace.
|
| org.springframework.jdbc.datasource.lookup |
Provides a strategy for looking up JDBC DataSources by name.
|
| org.springframework.jms.support.destination |
Support classes for Spring's JMS framework.
|
| org.springframework.jmx.export |
This package provides declarative creation and registration of
Spring-managed beans as JMX MBeans.
|
| org.springframework.jmx.export.annotation |
JDK 1.5+ annotations for MBean exposure.
|
| org.springframework.jndi |
The classes in this package make JNDI easier to use,
facilitating the accessing of configuration stored in JNDI,
and provide useful superclasses for JNDI access classes.
|
| org.springframework.orm.hibernate3 |
Package providing integration of
Hibernate 3.x
with Spring concepts.
|
| org.springframework.orm.hibernate3.support |
Classes supporting the
org.springframework.orm.hibernate3 package. |
| org.springframework.orm.jpa |
Package providing integration of JPA (Java Persistence API) with Spring concepts.
|
| org.springframework.orm.jpa.support |
Classes supporting the
org.springframework.orm.jpa package. |
| org.springframework.orm.jpa.vendor |
Support classes for adapting to specific JPA vendors.
|
| org.springframework.remoting.jaxws |
Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC),
as included in Java 6 and Java EE 5.
|
| org.springframework.scheduling.annotation |
JDK 1.5+ annotation for asynchronous method execution.
|
| org.springframework.scripting.groovy |
Package providing integration of
Groovy
into Spring's scripting infrastructure.
|
| org.springframework.scripting.support |
Support classes for Spring's scripting package.
|
| org.springframework.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
|
| org.springframework.web.context.request.async |
Support for asynchronous request processing.
|
| org.springframework.web.context.support |
Classes supporting the
org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
| org.springframework.web.servlet.mvc.annotation |
Support package for annotation-based Servlet MVC controllers.
|
| org.springframework.web.servlet.mvc.method.annotation |
MVC infrastructure for annotation-based handler method processing, building on the
org.springframework.web.method.annotation package. |
| Modifier and Type | Class and Description |
|---|---|
class |
AspectJExpressionPointcut
Spring
Pointcut implementation
that uses the AspectJ weaver to evaluate a pointcut expression. |
| 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. |
| 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 |
MethodLocatingFactoryBean
FactoryBean implementation that locates a Method on a specified bean. |
class |
SimpleBeanFactoryAwareAspectInstanceFactory
Implementation of
AspectInstanceFactory that locates the aspect from the
BeanFactory using a configured bean name. |
| Modifier and Type | Class and Description |
|---|---|
class |
ProxyFactoryBean
FactoryBean implementation that builds an
AOP proxy based on beans in Spring BeanFactory. |
| 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 |
AbstractBeanFactoryBasedTargetSourceCreator
Convenient superclass for
TargetSourceCreator
implementations that require creating multiple instances of a prototype bean. |
class |
LazyInitTargetSourceCreator
TargetSourceCreator that enforces a LazyInitTargetSource for each bean
that is defined as "lazy-init".
|
class |
QuickTargetSourceCreator
Convenient TargetSourceCreator using bean name prefixes to create one of three
well-known TargetSource types:
: CommonsPoolTargetSource
% ThreadLocalTargetSource
! PrototypeTargetSource
|
| Modifier and Type | Class and Description |
|---|---|
class |
AsyncExecutionAspectSupport
Base class for asynchronous method execution aspects, such as
AnnotationAsyncExecutionInterceptor
or org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect. |
class |
AsyncExecutionInterceptor
AOP Alliance
MethodInterceptor that processes method invocations
asynchronously, using a given AsyncTaskExecutor. |
| Modifier and Type | Class and Description |
|---|---|
class |
ScopedProxyFactoryBean
Convenient proxy factory bean for scoped objects.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractBeanFactoryPointcutAdvisor
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in a BeanFactory.
|
class |
DefaultBeanFactoryPointcutAdvisor
Concrete BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in the BeanFactory,
as well as the Pointcut to be configured through a bean property.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractBeanFactoryBasedTargetSource
Base class for
TargetSource implementations
that are based on a Spring BeanFactory,
delegating to Spring-managed bean instances. |
class |
AbstractPoolingTargetSource
Abstract base class for pooling
TargetSource
implementations which maintain a pool of target instances, acquiring and
releasing a target object from the pool for each method invocation. |
class |
AbstractPrototypeBasedTargetSource
Base class for dynamic
TargetSource implementations
that create new prototype bean instances to support a pooling or
new-instance-per-invocation strategy. |
class |
CommonsPoolTargetSource
TargetSource implementation that holds
objects in a configurable Apache Commons Pool. |
class |
LazyInitTargetSource
TargetSource that lazily accesses a
singleton bean from a BeanFactory. |
class |
PrototypeTargetSource
TargetSource implementation that
creates a new instance of the target bean for each request,
destroying each instance on release (after each request). |
class |
SimpleBeanTargetSource
Simple
TargetSource implementation,
freshly obtaining the specified target bean from its containing
Spring BeanFactory. |
class |
ThreadLocalTargetSource
Alternative to an object pool.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AutowiredAnnotationBeanPostProcessor
BeanPostProcessor implementation
that autowires annotated fields, setter methods and arbitrary config methods. |
class |
QualifierAnnotationAutowireCandidateResolver
AutowireCandidateResolver implementation that matches bean definition qualifiers
against qualifier annotations on the field or parameter to be autowired. |
class |
RequiredAnnotationBeanPostProcessor
BeanPostProcessor implementation
that enforces required JavaBean properties to have been configured. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractFactoryBean<T>
Simple template superclass for
FactoryBean implementations that
creates a singleton or a prototype object, depending on a flag. |
class |
BeanReferenceFactoryBean
Deprecated.
as of Spring 3.2, in favor of using regular bean name aliases
(which support placeholder parsing since Spring 2.5)
|
class |
ListFactoryBean
Simple factory for shared List instances.
|
class |
MapFactoryBean
Simple factory for shared Map instances.
|
class |
MethodInvokingFactoryBean
FactoryBean which returns a value which is the result of a static or instance
method invocation. |
class |
ObjectFactoryCreatingFactoryBean
A
FactoryBean implementation that
returns a value which is an ObjectFactory
that in turn returns a bean sourced from a BeanFactory. |
class |
PlaceholderConfigurerSupport
Abstract base class for property resource configurers that resolve placeholders
in bean definition property values.
|
class |
PreferencesPlaceholderConfigurer
Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's
Preferences API (
java.util.prefs). |
class |
PropertyPathFactoryBean
FactoryBean that evaluates a property path on a given target object. |
class |
PropertyPlaceholderConfigurer
PlaceholderConfigurerSupport subclass that resolves ${...} placeholders
against local properties and/or system properties
and environment variables. |
class |
ProviderCreatingFactoryBean
A
FactoryBean implementation that
returns a value which is a JSR-330 Provider that in turn
returns a bean sourced from a BeanFactory. |
class |
ServiceLocatorFactoryBean
A
FactoryBean implementation that takes an interface which must have one or more
methods with the signatures MyType xxx() or MyType xxx(MyIdType id)
(typically, MyService getService() or MyService getService(String id))
and creates a dynamic proxy which implements that interface, delegating to an
underlying BeanFactory. |
class |
SetFactoryBean
Simple factory for shared Set instances.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractServiceLoaderBasedFactoryBean
Abstract base class for FactoryBeans operating on the
JDK 1.6
ServiceLoader facility. |
class |
ServiceFactoryBean
FactoryBean that exposes the
'primary' service for the configured service class, obtained through
the JDK 1.6 ServiceLoader facility. |
class |
ServiceListFactoryBean
FactoryBean that exposes all
services for the configured service class, represented as a List of service objects,
obtained through the JDK 1.6 ServiceLoader facility. |
class |
ServiceLoaderFactoryBean
FactoryBean that exposes the
JDK 1.6 ServiceLoader for the configured service class. |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanConfigurerSupport
Convenient base class for bean configurers that can perform Dependency Injection
on objects (however they may be created).
|
| 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 |
MBeanExportConfiguration
@Configuration class that registers a AnnotationMBeanExporter bean. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractApplicationEventMulticaster
Abstract implementation of the
ApplicationEventMulticaster interface,
providing the basic listener registration facility. |
class |
SimpleApplicationEventMulticaster
Simple implementation of the
ApplicationEventMulticaster interface. |
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultLifecycleProcessor
Default implementation of the
LifecycleProcessor strategy. |
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 |
LoadTimeWeaverAwareProcessor
BeanPostProcessor
implementation that passes the context's default LoadTimeWeaver
to beans that implement the LoadTimeWeaverAware interface. |
| Modifier and Type | Class and Description |
|---|---|
class |
PersistenceExceptionTranslationPostProcessor
Bean post-processor that automatically applies persistence exception translation to any
bean marked with Spring's @
Repository
annotation, adding a corresponding PersistenceExceptionTranslationAdvisor to
the exposed proxy (either an existing AOP proxy or a newly generated proxy that
implements all of the target's interfaces). |
| Modifier and Type | Class and Description |
|---|---|
class |
PersistenceExceptionTranslationInterceptor
AOP Alliance MethodInterceptor that provides persistence exception translation
based on a given PersistenceExceptionTranslator.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SortedResourcesFactoryBean
FactoryBean implementation that takes a list of location Strings
and creates a sorted array of Resource instances. |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryDataSourceLookup
DataSourceLookup implementation based on a Spring BeanFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryDestinationResolver
DestinationResolver implementation based on a Spring BeanFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
MBeanExporter
JMX exporter that allows for exposing any Spring-managed bean to a
JMX
MBeanServer, without the need to define any
JMX-specific information in the bean classes. |
| Modifier and Type | Class and Description |
|---|---|
class |
AnnotationJmxAttributeSource
Implementation of the
JmxAttributeSource interface that
reads JDK 1.5+ annotations and exposes the corresponding attributes. |
class |
AnnotationMBeanExporter
Convenient subclass of Spring's standard
MBeanExporter,
activating Java 5 annotation usage for JMX exposure of Spring beans:
ManagedResource, ManagedAttribute, ManagedOperation, etc. |
| Modifier and Type | Class and Description |
|---|---|
class |
JndiObjectFactoryBean
FactoryBean that looks up a
JNDI object. |
| Modifier and Type | Class and Description |
|---|---|
class |
HibernateAccessor
Base class for
HibernateTemplate and HibernateInterceptor,
defining common properties such as SessionFactory and flushing behavior. |
class |
HibernateInterceptor
This interceptor binds a new Hibernate Session to the thread before a method
call, closing and removing it afterwards in case of any method outcome.
|
class |
HibernateTemplate
Helper class that simplifies Hibernate data access code.
|
class |
HibernateTransactionManager
PlatformTransactionManager
implementation for a single Hibernate SessionFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
OpenSessionInViewInterceptor
Spring web request interceptor that binds a Hibernate
Session to the
thread for the entire processing of the request. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractEntityManagerFactoryBean
Abstract
FactoryBean that
creates a local JPA EntityManagerFactory
instance within a Spring application context. |
class |
EntityManagerFactoryAccessor
Base class for any class that needs to access an EntityManagerFactory,
usually in order to obtain an EntityManager.
|
class |
JpaAccessor
Deprecated.
as of Spring 3.1, in favor of native EntityManager usage
(typically obtained through
@PersistenceContext) |
class |
JpaInterceptor
Deprecated.
as of Spring 3.1, in favor of native EntityManager usage
(typically obtained through
@PersistenceContext) and
AOP-driven exception translation through
PersistenceExceptionTranslationPostProcessor |
class |
JpaTemplate
Deprecated.
as of Spring 3.1, in favor of native EntityManager usage
(typically obtained through
@PersistenceContext)
Note that this class did not get upgraded to JPA 2.0 and never will. |
class |
JpaTransactionManager
PlatformTransactionManager implementation
for a single JPA EntityManagerFactory. |
class |
LocalContainerEntityManagerFactoryBean
FactoryBean that creates a JPA
EntityManagerFactory according to JPA's standard
container bootstrap contract. |
class |
LocalEntityManagerFactoryBean
FactoryBean that creates a JPA
EntityManagerFactory according to JPA's standard
standalone bootstrap contract. |
| Modifier and Type | Class and Description |
|---|---|
class |
OpenEntityManagerInViewInterceptor
Spring web request interceptor that binds a JPA EntityManager to the
thread for the entire processing of the request.
|
class |
PersistenceAnnotationBeanPostProcessor
BeanPostProcessor that processes
PersistenceUnit
and PersistenceContext annotations, for injection of
the corresponding JPA resources EntityManagerFactory
and EntityManager. |
class |
SharedEntityManagerBean
FactoryBean that exposes a shared JPA EntityManager
reference for a given EntityManagerFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
HibernateJpaSessionFactoryBean
Simple
FactoryBean that exposes the underlying SessionFactory
behind a Hibernate-backed JPA EntityManagerFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractJaxWsServiceExporter
Abstract exporter for JAX-WS services, autodetecting annotated service beans
(through the JAX-WS
WebService annotation). |
class |
SimpleHttpServerJaxWsServiceExporter
Simple exporter for JAX-WS services, autodetecting annotated service beans
(through the JAX-WS
WebService annotation) and exporting
them through the HTTP server included in Sun's JDK 1.6. |
class |
SimpleJaxWsServiceExporter
Simple exporter for JAX-WS services, autodetecting annotated service beans
(through the JAX-WS
WebService annotation) and exporting
them with a configured base address (by default "http://localhost:8080/")
using the JAX-WS provider's built-in publication support. |
| 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). |
| Modifier and Type | Class and Description |
|---|---|
class |
GroovyScriptFactory
ScriptFactory implementation
for a Groovy script. |
| 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 |
TransactionAspectSupport
Base class for transactional aspects, such as the
TransactionInterceptor
or an AspectJ aspect. |
class |
TransactionInterceptor
AOP Alliance MethodInterceptor for declarative transaction
management using the common Spring transaction infrastructure
(
PlatformTransactionManager). |
class |
TransactionProxyFactoryBean
Proxy factory bean for simplified declarative transaction handling.
|
| Modifier and Type | Class and Description |
|---|---|
class |
WebAsyncTask<V>
Holder for a
Callable, a timeout value, and a task executor. |
| 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 |
AnnotationMethodHandlerAdapter
Deprecated.
in Spring 3.2 in favor of
RequestMappingHandlerAdapter |
| Modifier and Type | Class and Description |
|---|---|
class |
RequestMappingHandlerAdapter
An
AbstractHandlerMethodAdapter that supports HandlerMethods
with the signature -- method argument and return types, defined in
@RequestMapping. |
Copyright © 2015. All rights reserved.