AbstractAdvisorAutoProxyCreator | Generic auto proxy creator that builds AOP proxies for specific beans based on detected Advisors for each bean. |
AbstractAnnotationAwareTransactionalTests |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
|
AbstractApplicationContext | Abstract implementation of the ApplicationContext
interface. |
AbstractApplicationEventMulticaster | Abstract implementation of the ApplicationEventMulticaster interface,
providing the basic listener registration facility. |
AbstractAspectJAdvice | Base class for AOP Alliance org.aopalliance.aop.Advice classes wrapping an AspectJ aspect or an AspectJ-annotated advice method. |
AbstractAspectJAdvisorFactory | Abstract base class for factories that can create Spring AOP Advisors given AspectJ classes from classes honoring the AspectJ 5 annotation syntax. |
AbstractAspectJAdvisorFactory.AspectJAnnotation<A extends Annotation> | Class modelling an AspectJ annotation, exposing its type enumeration and pointcut String. |
AbstractAspectJAdvisorFactory.AspectJAnnotationType | |
AbstractAspectjJpaTests |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
|
AbstractAtomFeedView | Abstract superclass for Atom Feed views, using java.net's ROME package. |
AbstractAutoProxyCreator | BeanPostProcessor implementation
that wraps each eligible bean with an AOP proxy, delegating to specified interceptors
before invoking the bean itself. |
AbstractAutowireCapableBeanFactory | Abstract bean factory superclass that implements default bean creation,
with the full capabilities specified by the RootBeanDefinition class. |
AbstractBeanDefinition | Base class for concrete, full-fledged
BeanDefinition classes,
factoring out common properties of RootBeanDefinition and
ChildBeanDefinition . |
AbstractBeanDefinitionParser | Abstract BeanDefinitionParser implementation providing
a number of convenience methods and a
template method
that subclasses must override to provide the actual parsing logic. |
AbstractBeanDefinitionReader | Abstract base class for bean definition readers which implement
the BeanDefinitionReader interface. |
AbstractBeanFactory | Abstract base class for BeanFactory
implementations, providing the full capabilities of the
ConfigurableBeanFactory SPI. |
AbstractBeanFactoryBasedTargetSource | Base class for TargetSource implementations
that are based on a Spring BeanFactory ,
delegating to Spring-managed bean instances. |
AbstractBeanFactoryBasedTargetSourceCreator | Convenient superclass for
TargetSourceCreator
implementations that require creating multiple instances of a prototype bean. |
AbstractBeanFactoryPointcutAdvisor | Abstract BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in a BeanFactory. |
AbstractBindingResult | Abstract implementation of the BindingResult interface and
its super-interface Errors . |
AbstractBufferingClientHttpRequest | Abstract base for ClientHttpRequest that buffers output in a byte array before sending it over the wire. |
AbstractCacheManager | Abstract base class implementing the common CacheManager methods. |
AbstractCachingLabeledEnumResolver | This class is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
AbstractCachingViewResolver | Convenient base class for ViewResolver
implementations. |
AbstractCheckedElementTag | Abstract base class to provide common methods for
implementing databinding-aware JSP tags for rendering an HTML 'input '
element with a 'type ' of 'checkbox ' or 'radio '. |
AbstractClassTestingTypeFilter | Type filter that exposes a
ClassMetadata object
to subclasses, for class testing purposes. |
AbstractClientHttpRequest | Abstract base for ClientHttpRequest that makes sure that headers and body are not written multiple times. |
AbstractColumnMaxValueIncrementer | Abstract base class for DataFieldMaxValueIncrementer implementations that use
a column in a custom sequence table. |
AbstractCommandController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
AbstractCommandController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
AbstractComponentDefinition | Base implementation of ComponentDefinition that provides a basic implementation of
getDescription() which delegates to getName() . |
AbstractConfigurableMBeanInfoAssembler | Base class for MBeanInfoAssemblers that support configurable JMX notification behavior. |
AbstractContextLoader | Abstract application context loader, which provides a basis for all concrete
implementations of the ContextLoader strategy. |
AbstractController | Convenient superclass for controller implementations, using the Template Method design pattern. |
AbstractController | Convenient superclass for controller implementations, using the Template Method design pattern. |
AbstractControllerUrlHandlerMapping | Base class for HandlerMapping implementations
that derive URL paths according to conventions for specific controller types. |
AbstractDataBoundFormElementTag | Base tag for all data-binding aware JSP form tags. |
AbstractDataFieldMaxValueIncrementer | Base implementation of DataFieldMaxValueIncrementer that delegates
to a single getNextKey() template method that returns a long . |
AbstractDataSource | Abstract base class for Spring's javax.sql.DataSource implementations, taking care of the padding. |
AbstractDelegatingCache<K, V> | Abstract base class delegating most of the Map-like methods to the underlying cache. |
AbstractDependencyInjectionSpringContextTests |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
|
AbstractDetectingUrlHandlerMapping | Abstract implementation of the HandlerMapping
interface, detecting URL mappings for handler beans through introspection of all
defined beans in the application context. |
AbstractDriverBasedDataSource | Abstract base class for JDBC javax.sql.DataSource implementations that operate on a JDBC java.sql.Driver. |
AbstractEnterpriseBean | Base class for Spring-based EJB 2.x beans. |
AbstractEntityManagerFactoryBean | Abstract FactoryBean that
creates a local JPA javax.persistence.EntityManagerFactory
instance within a Spring application context. |
AbstractEnvironment | Abstract base class for Environment implementations. |
AbstractErrors | Abstract implementation of the Errors interface. |
AbstractExcelView | Convenient superclass for Excel document views. |
AbstractExpressionPointcut | Abstract superclass for expression pointcuts, offering location and expression properties. |
AbstractFactoryBean<T> | Simple template superclass for FactoryBean implementations that
creates a singleton or a prototype object, depending on a flag. |
AbstractFallbackCacheDefinitionSource | Abstract implementation of CacheDefinition that caches
attributes for methods and implements a fallback policy: 1. |
AbstractFallbackSQLExceptionTranslator | Base class for SQLExceptionTranslator implementations that allow for
fallback to some other SQLExceptionTranslator . |
AbstractFallbackTransactionAttributeSource | Abstract implementation of TransactionAttributeSource that caches
attributes for methods and implements a fallback policy: 1. |
AbstractFeatureSpecification | TODO SPR-7420: document |
AbstractFeedView<T extends WireFeed> | Abstract base class for Atom and RSS Feed views, using java.net's ROME package. |
AbstractFileResolvingResource | Abstract base class for resources which resolve URLs into File references,
such as UrlResource or ClassPathResource . |
AbstractFormController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
AbstractFormController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
AbstractFormTag | Base class for all JSP form tags. |
AbstractGenericContextLoader | Abstract, generic extension of AbstractContextLoader which loads a
GenericApplicationContext from the locations provided to
loadContext(String) . |
AbstractGenericLabeledEnum | This class is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
AbstractGenericPointcutAdvisor | Abstract generic PointcutAdvisor that allows for any Advice to be configured. |
AbstractHandlerExceptionResolver | Abstract base class for HandlerExceptionResolver implementations. |
AbstractHandlerExceptionResolver | Abstract base class for HandlerExceptionResolver implementations. |
AbstractHandlerMapping | Abstract base class for HandlerMapping
implementations. |
AbstractHandlerMapping | Abstract base class for HandlerMapping
implementations. |
AbstractHtmlElementBodyTag | Convenient super class for many html tags that render content using the databinding
features of the AbstractHtmlElementTag . |
AbstractHtmlElementTag | Base class for databinding-aware JSP tags that render HTML element. |
AbstractHtmlInputElementTag | Base class for databinding-aware JSP tags that render HTML form input element. |
AbstractHttpInvokerRequestExecutor | Abstract base implementation of the HttpInvokerRequestExecutor interface. |
AbstractHttpMessageConverter<T> | Abstract base class for most HttpMessageConverter implementations. |
AbstractInterceptorDrivenBeanDefinitionDecorator | Base implementation for
BeanDefinitionDecorators
wishing to add an org.aopalliance.intercept.MethodInterceptor interceptor
to the resulting bean. |
AbstractInterruptibleBatchPreparedStatementSetter | Abstract implementation of the InterruptibleBatchPreparedStatementSetter
interface, combining the check for available values and setting of those
into a single callback method setValuesIfAvailable(PreparedStatement, int) . |
AbstractJasperReportsSingleFormatView | Extends AbstractJasperReportsView to provide basic rendering logic
for views that use a fixed format, e.g. |
AbstractJasperReportsView | Base class for all JasperReports views. |
AbstractJaxb2HttpMessageConverter<T> | Abstract base class for HttpMessageConverters that
use JAXB2. |
AbstractJaxWsServiceExporter | Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS javax.jws.WebService annotation). |
AbstractJdbcCall | Abstract class to provide base functionality for easy stored procedure calls based on configuration options and database metadata. |
AbstractJdbcInsert | Abstract class to provide base functionality for easy inserts based on configuration options and database metadata. |
AbstractJExcelView | Convenient superclass for Excel document views. |
AbstractJmsListeningContainer | Common base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt). |
AbstractJmsListeningContainer.SharedConnectionNotInitializedException | Exception that indicates that the initial setup of this container's shared JMS Connection failed. |
AbstractJmsMessageDrivenBean | Convenient base class for JMS-based EJB 2.x MDBs. |
AbstractJmxAttribute | Base class for all JMX metadata classes. |
AbstractJpaTests |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
|
AbstractJpaVendorAdapter | Abstract JpaVendorAdapter implementation that defines common properties,
to be translated into vendor-specific JPA properties by concrete subclasses. |
AbstractJUnit38SpringContextTests |
Abstract base TestCase which integrates the Spring TestContext
Framework and explicit |
AbstractJUnit4SpringContextTests |
Abstract base test class which integrates the Spring TestContext
Framework with explicit |
AbstractLabeledEnum | This class is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
AbstractLazyCreationTargetSource | TargetSource implementation that will
lazily create a user-managed object. |
AbstractLobCreatingPreparedStatementCallback | Abstract PreparedStatementCallback implementation that manages a LobCreator. |
AbstractLobHandler | Abstract base class for LobHandler implementations. |
AbstractLobStreamingResultSetExtractor | Abstract ResultSetExtractor implementation that assumes streaming of LOB data. |
AbstractLobType | Abstract base class for Hibernate UserType implementations that map to LOBs. |
AbstractLobTypeHandler | Abstract base class for iBATIS TypeHandler implementations that map to LOBs. |
AbstractLocaleResolver | Abstract base class for LocaleResolver implementations. |
AbstractMapBasedHandlerMapping<K> | Abstract base class for HandlerMapping
implementations that rely on a map which caches handler objects per lookup key. |
AbstractMapBasedHandlerMapping.PortletRequestMappingPredicate | Predicate interface for determining a match with a given request. |
AbstractMarshaller | Abstract implementation of the Marshaller and Unmarshaller interface. |
AbstractMBeanInfoAssembler | Abstract implementation of the MBeanInfoAssembler interface
that encapsulates the creation of a ModelMBeanInfo instance
but delegates the creation of metadata to subclasses. |
AbstractMessageDrivenBean | Convenient base class for EJB 2.x MDBs. |
AbstractMessageEndpointFactory | Abstract base implementation of the JCA 1.5/1.6 javax.resource.spi.endpoint.MessageEndpointFactory interface, providing transaction management capabilities as well as ClassLoader exposure for endpoint invocations. |
AbstractMessageEndpointFactory.AbstractMessageEndpoint | Inner class for actual endpoint implementations, based on template method to allow for any kind of concrete endpoint implementation. |
AbstractMessageListenerContainer | Abstract base class for message listener containers. |
AbstractMessageSource | Abstract implementation of the HierarchicalMessageSource interface,
implementing common handling of message variants, making it easy
to implement a specific strategy for a concrete MessageSource. |
AbstractModelAndViewTests |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
or ModelAndViewAssert with JUnit 4 and TestNG.
|
AbstractMonitoringInterceptor | Base class for monitoring interceptors, such as performance monitors. |
AbstractMultiCheckedElementTag | Abstract base class to provide common methods for implementing
databinding-aware JSP tags for rendering multiple
HTML 'input ' elements with a 'type '
of 'checkbox ' or 'radio '. |
AbstractMultipartHttpServletRequest | Abstract base implementation of the MultipartHttpServletRequest interface. |
AbstractNumberFormatter | Abstract formatter for Numbers,
providing a getNumberFormat(java.util.Locale) template method. |
AbstractPdfStamperView | Abstract superclass for PDF views that operate on an existing document with an AcroForm. |
AbstractPdfView | Abstract superclass for PDF views, using Bruno Lowagie's iText package. |
AbstractPlatformTransactionManager | Abstract base class that implements Spring's standard transaction workflow,
serving as basis for concrete platform transaction managers like
JtaTransactionManager . |
AbstractPlatformTransactionManager.SuspendedResourcesHolder | Holder for suspended resources. |
AbstractPointcutAdvisor | Abstract base class for PointcutAdvisor
implementations. |
AbstractPollingMessageListenerContainer | Base class for listener container implementations which are based on polling. |
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. |
AbstractPropertyAccessor | Abstract implementation of the PropertyAccessor interface. |
AbstractPropertyBindingResult | Abstract base class for BindingResult implementations that work with
Spring's PropertyAccessor mechanism. |
AbstractPropertyResolver | Abstract base class for resolving properties against any underlying source. |
AbstractPrototypeBasedTargetSource | Base class for dynamic TargetSource implementations that create new prototype bean instances to support a pooling or new-instance-per-invocation strategy. |
AbstractReflectiveMBeanInfoAssembler | Builds on the AbstractMBeanInfoAssembler superclass to
add a basic algorithm for building metadata based on the
reflective metadata of the MBean class. |
AbstractRefreshableApplicationContext | Base class for ApplicationContext
implementations which are supposed to support multiple calls to refresh() ,
creating a new internal bean factory instance every time. |
AbstractRefreshableConfigApplicationContext | AbstractRefreshableApplicationContext subclass that adds common handling
of specified config locations. |
AbstractRefreshablePortletApplicationContext | AbstractRefreshableApplicationContext
subclass which implements the ConfigurablePortletApplicationContext
interface for portlet environments. |
AbstractRefreshableTargetSource | Abstract TargetSource implementation that
wraps a refreshable target object. |
AbstractRefreshableWebApplicationContext | AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments. |
AbstractRegexpMethodPointcut | Abstract base regular expression pointcut bean. |
AbstractRemoteSlsbInvokerInterceptor | Base class for interceptors proxying remote Stateless Session Beans. |
AbstractRequestAttributes | Abstract support class for RequestAttributes implementations, offering a request completion mechanism for request-specific destruction callbacks and for updating accessed session attributes. |
AbstractRequestAttributesScope | Abstract Scope implementation that reads from a particular scope
in the current thread-bound RequestAttributes object. |
AbstractRequestLoggingFilter | Base class for Filter s that perform logging operations before and after a request is processed. |
AbstractResource | Convenience base class for Resource implementations,
pre-implementing typical behavior. |
AbstractRoutingDataSource | Abstract javax.sql.DataSource implementation that routes getConnection()
calls to one of various target DataSources based on a lookup key. |
AbstractRssFeedView | Abstract superclass for RSS Feed views, using java.net's ROME package. |
AbstractSequenceMaxValueIncrementer | Abstract base class for DataFieldMaxValueIncrementer implementations that use
a database sequence. |
AbstractServiceLoaderBasedFactoryBean | Abstract base class for FactoryBeans operating on the JDK 1.6 java.util.ServiceLoader facility. |
AbstractSessionBean | Base class for Spring-based EJB 2.x session beans. |
AbstractSessionFactoryBean | Abstract FactoryBean that creates
a Hibernate org.hibernate.SessionFactory within a Spring application
context, providing general infrastructure not related to Hibernate's
specific configuration API. |
AbstractSimpleBeanDefinitionParser | Convenient base class for when there exists a one-to-one mapping between attribute names on the element that is to be parsed and the property names on the Class being configured. |
AbstractSingleBeanDefinitionParser | Base class for those BeanDefinitionParser implementations that
need to parse and define just a single BeanDefinition . |
AbstractSingleCheckedElementTag | Abstract base class to provide common methods for implementing
databinding-aware JSP tags for rendering a single
HTML 'input ' element with a 'type '
of 'checkbox ' or 'radio '. |
AbstractSingleSpringContextTests |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
|
AbstractSingletonProxyFactoryBean | Convenient proxy factory bean superclass for proxy factory beans that create only singletons. |
AbstractSlsbInvokerInterceptor | Base class for AOP interceptors invoking local or remote Stateless Session Beans. |
AbstractSpecificationBeanDefinitionParser | TODO SPR-7420: document |
AbstractSpecificationExecutor<S extends FeatureSpecification> | TODO SPR-7420: document |
AbstractSpringContextTests |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
|
AbstractSpringPreparerFactory | Abstract implementation of the Tiles2 org.apache.tiles.preparer.PreparerFactory
interface, obtaining the current Spring WebApplicationContext and delegating to
getPreparer(String, org.springframework.web.context.WebApplicationContext) . |
AbstractSqlParameterSource | Abstract base class for SqlParameterSource implementations. |
AbstractSqlTypeValue | Abstract implementation of the SqlTypeValue interface, for convenient
creation of type values that are supposed to be passed into the
PreparedStatement.setObject method. |
AbstractStatefulSessionBean | Convenient base class for EJB 2.x stateful session beans (SFSBs). |
AbstractStatelessSessionBean | Convenient base class for EJB 2.x stateless session beans (SLSBs), minimizing the work involved in implementing an SLSB and preventing common errors. |
AbstractTemplateView | Adapter base class for template-based view technologies such as Velocity and FreeMarker, with the ability to use request and session attributes in their model and the option to expose helper objects for Spring's Velocity/FreeMarker macro library. |
AbstractTemplateViewResolver | Abstract base class for template view resolvers, in particular for Velocity and FreeMarker views. |
AbstractTestExecutionListener | Abstract implementation of the TestExecutionListener interface which
provides empty method stubs. |
AbstractTestNGSpringContextTests |
Abstract base test class which integrates the
Spring TestContext Framework with explicit
|
AbstractThemeResolver | Abstract base class for ThemeResolver implementations. |
AbstractTraceInterceptor | Base MethodInterceptor implementation for tracing. |
AbstractTransactionalDataSourceSpringContextTests |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
|
AbstractTransactionalJUnit38SpringContextTests |
Abstract |
AbstractTransactionalJUnit4SpringContextTests |
Abstract |
AbstractTransactionalSpringContextTests |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
|
AbstractTransactionalTestNGSpringContextTests |
Abstract |
AbstractTransactionStatus | Abstract base implementation of the
TransactionStatus interface. |
AbstractTypeHierarchyTraversingFilter | Type filter that is aware of traversing over hierarchy. |
AbstractUrlBasedView | Abstract base class for URL-based views. |
AbstractUrlHandlerMapping | Abstract base class for URL-mapped HandlerMapping
implementations. |
AbstractUrlMethodNameResolver | Abstract base class for URL-based MethodNameResolver implementations. |
AbstractUrlViewController | Abstract base class for Controllers that return a view name
based on the request URL. |
AbstractView | Abstract base class for View
implementations. |
AbstractWireFeedHttpMessageConverter<T extends WireFeed> | Abstract base class for Atom and RSS Feed message converters, using java.net's ROME package. |
AbstractWizardFormController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
AbstractWizardFormController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
AbstractXmlApplicationContext | Convenient base class for ApplicationContext
implementations, drawing configuration from XML documents containing bean definitions
understood by an XmlBeanDefinitionReader . |
AbstractXmlHttpMessageConverter<T> | Abstract base class for HttpMessageConverters
that convert from/to XML. |
AbstractXsltView |
This class is deprecated.
since Spring 2.5; superseded by XsltView and its
more flexible locateSource(Map mechanism
|
AcceptHeaderLocaleResolver | Implementation of LocaleResolver that simply uses the primary locale specified in the "accept-language" header of the HTTP request (that is, the locale sent by the client browser, normally that of the client's OS). |
AccessException | An AccessException is thrown by an accessor if it has an unexpected problem. |
ActionMapping | Annotation for mapping Portlet action requests onto handler methods. |
ActionSupport | This class is deprecated. as of Spring 3.0 |
AdaptableJobFactory | JobFactory implementation that supports java.lang.Runnable objects as well as standard Quartz org.quartz.Job instances. |
AdviceEntry | ParseState entry representing an advice element. |
AdviceMode | TODO SPR-7420: document |
Advised | Interface to be implemented by classes that hold the configuration of a factory of AOP proxies. |
AdvisedSupport | Base class for AOP proxy configuration managers. |
AdvisedSupportListener | Listener to be registered on ProxyCreatorSupport objects
Allows for receiving callbacks on activation and change of advice. |
Advisor | Base interface holding AOP advice (action to take at a joinpoint) and a filter determining the applicability of the advice (such as a pointcut). |
AdvisorAdapter | Interface allowing extension to the Spring AOP framework to allow handling of new Advisors and Advice types. |
AdvisorAdapterRegistrationManager | BeanPostProcessor that registers AdvisorAdapter beans in the BeanFactory with
an AdvisorAdapterRegistry (by default the GlobalAdvisorAdapterRegistry ). |
AdvisorAdapterRegistry | Interface for registries of Advisor adapters. |
AdvisorChainFactory | Factory interface for advisor chains. |
AdvisorComponentDefinition | ComponentDefinition
that bridges the gap between the advisor bean definition configured
by the <aop:advisor> tag and the component definition
infrastructure. |
AdvisorEntry | ParseState entry representing an advisor. |
AfterAdvice | Common marker interface for after advice,
such as AfterReturningAdvice and ThrowsAdvice . |
AfterReturningAdvice | After returning advice is invoked only on normal method return, not if an exception is thrown. |
AfterReturningAdviceInterceptor | Interceptor to wrap am AfterReturningAdvice . |
AfterTransaction |
Test annotation to indicate that the annotated |
AliasDefinition | Representation of an alias that has been registered during the parsing process. |
AliasRegistry | Common interface for managing aliases. |
AnnotatedBeanDefinition | Extended BeanDefinition
interface that exposes AnnotationMetadata
about its bean class - without requiring the class to be loaded yet. |
AnnotatedBeanDefinitionReader | Convenient adapter for programmatic registration of annotated bean classes. |
AnnotatedGenericBeanDefinition | Extension of the GenericBeanDefinition
class, adding support for annotation metadata exposed through the
AnnotatedBeanDefinition interface. |
AnnotationAwareAspectJAutoProxyCreator | AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ
annotation aspects in the current application context, as well as Spring Advisors. |
AnnotationAwareOrderComparator | java.util.Comparator implementation that checks
Ordered as well as the
Order annotation, with an order value provided by an
Ordered instance overriding a statically defined
annotation value (if any). |
AnnotationBeanNameGenerator | BeanNameGenerator
implementation for bean classes annotated with the
@Component annotation
or with another annotation that is itself annotated with
@Component as a
meta-annotation. |
AnnotationBeanUtils | General utility methods for working with annotations in JavaBeans style. |
AnnotationBeanWiringInfoResolver | BeanWiringInfoResolver that
uses the Configurable annotation to identify which classes need autowiring. |
AnnotationCacheDefinitionSource | Implementation of the
CacheDefinitionSource
interface for working with caching metadata in JDK 1.5+ annotation format. |
AnnotationClassFilter | Simple ClassFilter that looks for a specific Java 5 annotation being present on a class. |
AnnotationConfigApplicationContext | Standalone application context, accepting annotated classes as input - in particular
@Configuration -annotated
classes, but also plain @Components
and JSR-330 compliant classes using javax.inject annotations. |
AnnotationConfigBeanDefinitionParser | Parser for the <context:annotation-config/> element. |
AnnotationConfigUtils | Utility class that allows for convenient registration of common
BeanPostProcessor and
BeanFactoryPostProcessor
definitions for annotation-based configuration. |
AnnotationConfigWebApplicationContext | WebApplicationContext implementation
which accepts annotated classes as input - in particular
@Configuration -annotated
classes, but also plain @Components
and JSR-330 compliant classes using javax.inject annotations. |
AnnotationDrivenBeanDefinitionParser | Parser for the 'annotation-driven' element of the 'task' namespace. |
AnnotationFormatterFactory<A extends Annotation> | A factory that creates formatters to format values of fields annotated with a particular Annotation . |
AnnotationJmxAttributeSource | Implementation of the JmxAttributeSource interface that
reads JDK 1.5+ annotations and exposes the corresponding attributes. |
AnnotationMatchingPointcut | Simple Pointcut that looks for a specific Java 5 annotation
being present on a class or
method . |
AnnotationMBeanExporter | Convenient subclass of Spring's standard MBeanExporter ,
activating Java 5 annotation usage for JMX exposure of Spring beans:
ManagedResource , ManagedAttribute , ManagedOperation , etc. |
AnnotationMetadata | Interface that defines abstract access to the annotations of a specific class, in a form that does not require that class to be loaded yet. |
AnnotationMethodHandlerAdapter | Implementation of the HandlerAdapter
interface that maps handler methods based on portlet modes, action/render phases
and request parameters expressed through the RequestMapping annotation. |
AnnotationMethodHandlerAdapter | Implementation of the HandlerAdapter interface
that maps handler methods based on HTTP paths, HTTP methods and request parameters
expressed through the RequestMapping annotation. |
AnnotationMethodHandlerExceptionResolver | Implementation of the HandlerExceptionResolver interface that handles
exceptions through the ExceptionHandler annotation. |
AnnotationMethodHandlerExceptionResolver | Implementation of the HandlerExceptionResolver interface that handles
exceptions through the ExceptionHandler annotation. |
AnnotationMethodMatcher | Simple MethodMatcher that looks for a specific Java 5 annotation being present on a method (checking both the method on the invoked interface, if any, and the corresponding method on the target class). |
AnnotationScopeMetadataResolver | A ScopeMetadataResolver implementation that by default checks for
the presence of Spring's Scope annotation on the bean class. |
AnnotationSessionFactoryBean | Subclass of Spring's standard LocalSessionFactoryBean for Hibernate, supporting JDK 1.5+ annotation metadata for mappings. |
AnnotationTransactionAttributeSource | Implementation of the
TransactionAttributeSource
interface for working with transaction metadata in JDK 1.5+ annotation format. |
AnnotationTypeFilter | A simple filter which matches classes with a given annotation, checking inherited annotations as well. |
AnnotationUtils | General utility methods for working with annotations, handling bridge methods (which the compiler generates for generic declarations) as well as super methods (for optional "annotation inheritance"). |
AntPathMatcher | PathMatcher implementation for Ant-style path patterns. |
AopConfigException | Exception that gets thrown on illegal AOP configuration arguments. |
AopConfigUtils | Utility class for handling registration of AOP auto-proxy creators. |
AopContext | Class containing static methods used to obtain information about the current AOP invocation. |
AopInfrastructureBean | Marker interface that indicates a bean that is part of Spring's AOP infrastructure. |
AopInvocationException | Exception that gets thrown when an AOP invocation failed because of misconfiguration or unexpected runtime issues. |
AopNamespaceHandler | NamespaceHandler for the aop namespace. |
AopNamespaceUtils | Utility class for handling registration of auto-proxy creators used internally
by the 'aop ' namespace tags. |
AopProxy | Delegate interface for a configured AOP proxy, allowing for the creation of actual proxy objects. |
AopProxyFactory | Interface to be implemented by factories that are able to create
AOP proxies based on AdvisedSupport configuration objects. |
AopProxyUtils | Utility methods for AOP proxy factories. |
AopUtils | Utility methods for AOP support code. |
ApplicationContext | Central interface to provide configuration for an application. |
ApplicationContextAware | Interface to be implemented by any object that wishes to be notified
of the ApplicationContext that it runs in. |
ApplicationContextEvent | Base class for events raised for an ApplicationContext . |
ApplicationContextException | Exception thrown during application context initialization. |
ApplicationContextInitializer<C extends ConfigurableApplicationContext> | Callback interface for initializing a Spring ConfigurableApplicationContext
prior to being refreshed . |
ApplicationEvent | Class to be extended by all application events. |
ApplicationEventMulticaster | Interface to be implemented by objects that can manage a number of
ApplicationListener objects, and publish events to them. |
ApplicationEventPublisher | Interface that encapsulates event publication functionality. |
ApplicationEventPublisherAware | Interface to be implemented by any object that wishes to be notified of the ApplicationEventPublisher (typically the ApplicationContext) that it runs in. |
ApplicationListener<E extends ApplicationEvent> | Interface to be implemented by application event listeners. |
ApplicationObjectSupport | Convenient superclass for application objects that want to be aware of the application context, e.g. |
ArgumentConvertingMethodInvoker | Subclass of MethodInvoker that tries to convert the given
arguments for the actual target method via a TypeConverter . |
AspectComponentDefinition | ComponentDefinition
that holds an aspect definition, including its nested pointcuts. |
AspectEntry | ParseState entry representing an aspect. |
AspectInstanceFactory | Interface implemented to provide an instance of an AspectJ aspect. |
AspectJAdviceParameterNameDiscoverer | ParameterNameDiscoverer implementation that tries to deduce parameter names
for an advice method from the pointcut expression, returning, and throwing clauses. |
AspectJAdviceParameterNameDiscoverer.AmbiguousBindingException | Thrown in response to an ambiguous binding being detected when trying to resolve a method's parameter names. |
AspectJAdvisorFactory | Interface for factories that can create Spring AOP Advisors from classes annotated with AspectJ annotation syntax. |
AspectJAfterAdvice | Spring AOP advice wrapping an AspectJ after advice method. |
AspectJAfterReturningAdvice | Spring AOP advice wrapping an AspectJ after-returning advice method. |
AspectJAfterThrowingAdvice | Spring AOP advice wrapping an AspectJ after-throwing advice method. |
AspectJAopUtils | Utility methods for dealing with AspectJ advisors. |
AspectJAroundAdvice | Spring AOP around advice (MethodInterceptor) that wraps an AspectJ advice method. |
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. |
AspectJExpressionPointcut | Spring Pointcut implementation
that uses the AspectJ weaver to evaluate a pointcut expression. |
AspectJExpressionPointcutAdvisor | Spring AOP Advisor that can be used for any AspectJ pointcut expression. |
AspectJMethodBeforeAdvice | Spring AOP advice that wraps an AspectJ before method. |
AspectJPointcutAdvisor | AspectJPointcutAdvisor that adapts an AbstractAspectJAdvice
to the PointcutAdvisor interface. |
AspectJPrecedenceInformation | Interface to be implemented by types that can supply the information needed to sort advice/advisors by AspectJ's precedence rules. |
AspectJProxyFactory | AspectJ-based proxy factory, allowing for programmatic building of proxies which include AspectJ aspects (code style as well Java 5 annotation style). |
AspectJProxyUtils | Utility methods for working with AspectJ proxies. |
AspectJTypeFilter | Type filter that uses AspectJ type pattern for matching. |
AspectJWeaverMessageHandler | Implementation of AspectJ's IMessageHandler interface that routes AspectJ weaving messages through the same logging system as the regular Spring messages. |
AspectJWeavingEnabler | Post-processor that registers AspectJ's
org.aspectj.weaver.loadtime.ClassPreProcessorAgentAdapter
with the Spring application context's default
LoadTimeWeaver . |
AspectMetadata | Metadata for an AspectJ aspect class, with an additional Spring AOP pointcut for the per clause. |
Assert | Assertion utility class that assists in validating arguments. |
AssertThrows |
This class is deprecated.
favor use of JUnit 4's @Test(expected=...) support
|
Assign | Represents assignment. |
AssignableTypeFilter | A simple filter which matches classes that are assignable to a given type. |
AstUtils | Utilities methods for use in the Ast classes. |
Async | Annotation that marks a method as a candidate for asynchronous execution. |
AsyncAnnotationAdvisor | Advisor that activates asynchronous method execution through the Async
annotation. |
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). |
AsyncExecutionInterceptor | AOP Alliance MethodInterceptor that processes method invocations
asynchronously, using a given AsyncTaskExecutor . |
AsyncResult<V> | A pass-through Future handle that can be used for method signatures
which are declared with a Future return type for asynchronous execution. |
AsyncTaskExecutor | Extended interface for asynchronous TaskExecutor implementations,
offering an overloaded execute(Runnable, long) variant with a start
timeout parameter as well support for java.util.concurrent.Callable. |
AtomFeedHttpMessageConverter | Implementation of HttpMessageConverter that can read and write Atom feeds. |
AttributeAccessor | Interface defining a generic contract for attaching and accessing metadata to/from arbitrary objects. |
AttributeAccessorSupport | Support class for AttributeAccessors , providing
a base implementation of all methods. |
AutodetectCapableMBeanInfoAssembler | Extends the MBeanInfoAssembler to add autodetection logic. |
AutoPopulatingList<E> | Simple List wrapper class that allows for elements to be automatically populated as they are requested. |
AutoPopulatingList.ElementFactory<E> | Factory interface for creating elements for an index-based access data structure such as a java.util.List. |
AutoPopulatingList.ElementInstantiationException | Exception to be thrown from ElementFactory. |
AutoProxyUtils | Utilities for auto-proxy aware components. |
Autowire | Enumeration determining autowiring status: that is, whether a bean should have its dependencies automatically injected by the Spring container using setter injection. |
AutowireCandidateQualifier | Qualifier for resolving autowire candidates. |
AutowireCandidateResolver | Strategy interface for determining whether a specific bean definition qualifies as an autowire candidate for a specific dependency. |
AutowireCapableBeanFactory | Extension of the BeanFactory
interface to be implemented by bean factories that are capable of
autowiring, provided that they want to expose this functionality for
existing bean instances. |
Autowired | Marks a constructor, field, setter method or config method as to be autowired by Spring's dependency injection facilities. |
AutowiredAnnotationBeanPostProcessor | BeanPostProcessor implementation
that autowires annotated fields, setter methods and arbitrary config methods. |
AutowiringRequestProcessor | This class is deprecated. as of Spring 3.0 |
AutowiringTilesRequestProcessor | This class is deprecated. as of Spring 3.0 |
Aware | Marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method. |
BadSqlGrammarException | Exception thrown when SQL specified is invalid. |
BaseCommandController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
BaseCommandController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
BatchPreparedStatementSetter | Batch update callback interface used by the JdbcTemplate class. |
BatchSqlUpdate | SqlUpdate subclass that performs batch update operations. |
BatchUpdateUtils | Generic utility methods for working with JDBC batch statements. |
Bean | Indicates that a method produces a bean to be managed by the Spring container. |
BeanClassLoaderAware | Callback that allows a bean to be aware of the bean ClassLoader class loader; that is, the class loader used by the present bean factory to load bean classes. |
BeanComponentDefinition | ComponentDefinition based on a standard BeanDefinition, exposing the given bean definition as well as inner bean definitions and bean references for the given bean. |
BeanConfigurerSupport | Convenient base class for configurers that can perform Dependency Injection on objects (however they may be created). |
BeanCreationException | Exception thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition. |
BeanCreationNotAllowedException | Exception thrown in case of a bean being requested despite bean creation currently not being allowed (for example, during the shutdown phase of a bean factory). |
BeanCurrentlyInCreationException | Exception thrown in case of a reference to a bean that's currently in creation. |
BeanDefinition | A BeanDefinition describes a bean instance, which has property values, constructor argument values, and further information supplied by concrete implementations. |
BeanDefinitionBuilder | Programmatic means of constructing
BeanDefinitions
using the builder pattern. |
BeanDefinitionDecorator | Interface used by the DefaultBeanDefinitionDocumentReader
to handle custom, nested (directly under a <bean> ) tags. |
BeanDefinitionDefaults | A simple holder for BeanDefinition property defaults. |
BeanDefinitionDocumentReader | SPI for parsing an XML document that contains Spring bean definitions. |
BeanDefinitionHolder | Holder for a BeanDefinition with name and aliases. |
BeanDefinitionParser | Interface used by the DefaultBeanDefinitionDocumentReader to handle custom,
top-level (directly under <beans> ) tags. |
BeanDefinitionParserDelegate | Stateful delegate class used to parse XML bean definitions. |
BeanDefinitionParsingException | Exception thrown when a bean definition reader encounters an error during the parsing process. |
BeanDefinitionReader | Simple interface for bean definition readers. |
BeanDefinitionReaderUtils | Utility methods that are useful for bean definition reader implementations. |
BeanDefinitionRegistry | Interface for registries that hold bean definitions, for example RootBeanDefinition and ChildBeanDefinition instances. |
BeanDefinitionRegistryPostProcessor | Extension to the standard BeanFactoryPostProcessor SPI, allowing for
the registration of further bean definitions before regular
BeanFactoryPostProcessor detection kicks in. |
BeanDefinitionStoreException | Exception thrown when a BeanFactory encounters an invalid bean definition: e.g. |
BeanDefinitionValidationException | Exception thrown when the validation of a bean definition failed. |
BeanDefinitionVisitor | Visitor class for traversing BeanDefinition objects, in particular
the property values and constructor argument values contained in them,
resolving bean metadata values. |
BeanEntry | ParseState entry representing a bean definition. |
BeanExpressionContext | Context object for evaluating an expression within a bean definition. |
BeanExpressionContextAccessor | EL property accessor that knows how to traverse the beans and contextual objects
of a Spring BeanExpressionContext . |
BeanExpressionException | Exception that indicates an expression evaluation attempt having failed. |
BeanExpressionResolver | Strategy interface for resolving a value through evaluating it as an expression, if applicable. |
BeanFactory | The root interface for accessing a Spring bean container. |
BeanFactoryAccessor | EL property accessor that knows how to traverse the beans of a
Spring BeanFactory . |
BeanFactoryAdvisorRetrievalHelper | Helper for retrieving standard Spring Advisors from a BeanFactory, for use with auto-proxying. |
BeanFactoryAspectInstanceFactory | AspectInstanceFactory implementation
backed by a Spring BeanFactory . |
BeanFactoryAspectJAdvisorsBuilder | Helper for retrieving @AspectJ beans from a BeanFactory and building Spring Advisors based on them, for use with auto-proxying. |
BeanFactoryAware | Interface to be implemented by beans that wish to be aware of their
owning BeanFactory . |
BeanFactoryCacheDefinitionSourceAdvisor | Advisor driven by a CacheDefinitionSource , used to include a
transaction advice bean for methods that are transactional. |
BeanFactoryDataSourceLookup | DataSourceLookup implementation based on a Spring BeanFactory . |
BeanFactoryDestinationResolver | DestinationResolver implementation based on a Spring BeanFactory . |
BeanFactoryLocator | Defines a contract for the lookup, use, and release of a
BeanFactory ,
or a BeanFactory subclass such as an
ApplicationContext . |
BeanFactoryPostProcessor | Allows for custom modification of an application context's bean definitions, adapting the bean property values of the context's underlying bean factory. |
BeanFactoryReference | Used to track a reference to a BeanFactory obtained through
a BeanFactoryLocator . |
BeanFactoryRefreshableTargetSource | Refreshable TargetSource that fetches fresh target beans from a BeanFactory. |
BeanFactoryResolver | EL bean resolver that operates against a Spring
BeanFactory . |
BeanFactoryTransactionAttributeSourceAdvisor | Advisor driven by a TransactionAttributeSource , used to include
a transaction advice bean for methods that are transactional. |
BeanFactoryUtils | Convenience methods operating on bean factories, in particular
on the ListableBeanFactory interface. |
BeanInitializationException | Exception that a bean implementation is suggested to throw if its own factory-aware initialization code fails. |
BeanInstantiationException | Exception thrown when instantiation of a bean failed. |
BeanIsAbstractException | Exception thrown when a bean instance has been requested for a bean definition which has been marked as abstract. |
BeanIsNotAFactoryException | Exception thrown when a bean is not a factory, but a user tries to get at the factory for the given bean name. |
BeanMetadataAttribute | Holder for a key-value style attribute that is part of a bean definition. |
BeanMetadataAttributeAccessor | Extension of AttributeAccessorSupport ,
holding attributes as BeanMetadataAttribute objects in order
to keep track of the definition source. |
BeanMetadataElement | Interface to be implemented by bean metadata elements that carry a configuration source object. |
BeanNameAutoProxyCreator | Auto proxy creator that identifies beans to proxy via a list of names. |
BeanNameAware | Interface to be implemented by beans that want to be aware of their bean name in a bean factory. |
BeanNameGenerator | Strategy interface for generating bean names for bean definitions. |
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. |
BeanNameViewResolver | Simple implementation of ViewResolver that interprets a view name as bean name in the current application context, i.e. |
BeanNotOfRequiredTypeException | Thrown when a bean doesn't match the expected type. |
BeanPostProcessor | Factory hook that allows for custom modification of new bean instances, e.g. |
BeanPropertyBindingResult | Default implementation of the Errors and BindingResult
interfaces, for the registration and evaluation of binding errors on
JavaBean objects. |
BeanPropertyRowMapper<T> | RowMapper implementation that converts a row into a new instance
of the specified mapped target class. |
BeanPropertySqlParameterSource | SqlParameterSource implementation that obtains parameter values
from bean properties of a given JavaBean object. |
BeanReference | Interface that exposes a reference to a bean name in an abstract fashion. |
BeanReference | Represents a bean reference to a type, for example "@foo" or "@'foo.bar'" |
BeanReferenceFactoryBean | FactoryBean that exposes an arbitrary target bean under a different name. |
BeanResolver | A bean resolver can be registered with the evaluation context
and will kick in for @myBeanName still expressions. |
BeansDtdResolver | EntityResolver implementation for the Spring beans DTD, to load the DTD from the Spring class path (or JAR file). |
BeansException | Abstract superclass for all exceptions thrown in the beans package and subpackages. |
BeanUtils | Static convenience methods for JavaBeans: for instantiating beans, checking bean property types, copying bean properties, etc. |
BeanValidationPostProcessor | Simple BeanPostProcessor that checks JSR-303 constraint annotations
in Spring-managed beans, throwing an initialization exception in case of
constraint violations right before calling the bean's init method (if any). |
BeanWiringInfo | Holder for bean wiring metadata information about a particular class. |
BeanWiringInfoResolver | Strategy interface to be implemented by objects than can resolve bean name information, given a newly instantiated bean object. |
BeanWrapper | The central interface of Spring's low-level JavaBeans infrastructure. |
BeanWrapperImpl | Default BeanWrapper implementation that should be sufficient
for all typical use cases. |
BeforeAdvice | Common marker interface for before advice, such as MethodBeforeAdvice . |
BeforeTransaction |
Test annotation to indicate that the annotated |
BindErrorsTag | JSP tag that evaluates content if there are binding errors for a certain bean. |
BindException | Thrown when binding errors are considered fatal. |
BindingAwareModelMap | Subclass of ExtendedModelMap that
automatically removes a BindingResult
object if the corresponding target attribute gets replaced. |
BindingErrorProcessor | Strategy for processing DataBinder 's missing field errors,
and for translating a PropertyAccessException to a
FieldError . |
BindingResult | General interface that represents binding results. |
BindingResultUtils | Convenience methods for looking up BindingResults in a model Map. |
BindStatus | Simple adapter to expose the bind status of a field or object. |
BindTag | Bind tag, supporting evaluation of binding errors for a certain bean or bean property. |
BlobByteArrayType | Hibernate UserType implementation for byte arrays that get mapped to BLOBs. |
BlobByteArrayTypeHandler | iBATIS TypeHandler implementation for byte arrays that get mapped to BLOBs. |
BlobSerializableType | Hibernate UserType implementation for arbitrary objects that get serialized to BLOBs. |
BlobSerializableTypeHandler | iBATIS TypeHandler implementation for arbitrary objects that get serialized to BLOBs. |
BlobStringType | Hibernate UserType implementation for Strings that get mapped to BLOBs. |
BooleanComparator | A Comparator for Boolean objects that can sort either true or false first. |
BooleanLiteral | Represents the literal values TRUE and FALSE. |
BooleanTypedValue | |
BootstrapContextAware | Interface to be implemented by any object that wishes to be
notified of the BootstrapContext (typically determined by the
ResourceAdapterApplicationContext ) that it runs in. |
BootstrapException | Exception thrown if a bean factory could not be loaded by a bootstrap class. |
BridgeMethodResolver | Helper for resolving synthetic bridge Methods to the
Method being bridged. |
BrowserCallback<T> | Callback for browsing the messages in a JMS queue. |
BshScriptFactory | ScriptFactory implementation
for a BeanShell script. |
BshScriptUtils | Utility methods for handling BeanShell-scripted objects. |
BshScriptUtils.BshExecutionException | Exception to be thrown on script execution failure. |
BufferedImageHttpMessageConverter | Implementation of HttpMessageConverter that can read and write BufferedImage BufferedImages. |
BurlapClientInterceptor | org.aopalliance.intercept.MethodInterceptor for accessing a Burlap service. |
BurlapExporter | General stream-based protocol exporter for a Burlap endpoint. |
BurlapProxyFactoryBean | FactoryBean for Burlap proxies. |
BurlapServiceExporter | Servlet-API-based HTTP request handler that exports the specified service bean as Burlap service endpoint, accessible via a Burlap proxy. |
ByteArrayHttpMessageConverter | Implementation of HttpMessageConverter that can read and write byte arrays. |
ByteArrayMultipartFileEditor | Custom java.beans.PropertyEditor for converting
MultipartFiles to byte arrays. |
ByteArrayPropertyEditor | Editor for byte arrays. |
ByteArrayResource | Resource implementation for a given byte array. |
C3P0NativeJdbcExtractor | Implementation of the NativeJdbcExtractor interface for the
C3P0 connection pool. |
Cache<K, V> | Interface that defines the common cache operations. |
Cacheable | Annotation indicating that a method (or all the methods on a class) can be cached. |
CacheAnnotationParser | Strategy interface for parsing known caching annotation types. |
CacheAspectSupport | Base class for caching aspects, such as the CacheInterceptor
or an AspectJ aspect. |
CacheAspectSupport.CacheOperationContext | |
CacheDefinition | Interface describing Spring-compliant caching operation. |
CacheDefinitionSource | Interface used by CacheInterceptor. |
CachedIntrospectionResults | Internal class that caches JavaBeans java.beans.PropertyDescriptor information for a Java class. |
CacheEvict | Annotation indicating that a method (or all methods on a class) trigger(s) a cache invalidate operation. |
CacheInterceptor | AOP Alliance MethodInterceptor for declarative cache
management using the common Spring caching infrastructure
(Cache ). |
CacheInvalidateDefinition | Interface describing a Spring cache invalidation. |
CacheManager | Entity managing Cache s. |
CacheNamespaceHandler | NamespaceHandler allowing for the configuration of
declarative cache management using either XML or using annotations. |
CacheProxyFactoryBean | Proxy factory bean for simplified declarative caching handling. |
CacheUpdateDefinition | Interface describing a Spring cache update. |
CachingConnectionFactory | SingleConnectionFactory subclass that adds javax.jms.Session
caching as well javax.jms.MessageProducer caching. |
CachingDestinationResolver | Extension of the DestinationResolver interface, exposing methods for clearing the cache. |
CachingMapDecorator<K, V> | A simple decorator for a Map, encapsulating the workflow for caching expensive values in a target Map. |
CachingMetadataReaderFactory | Caching implementation of the MetadataReaderFactory interface,
caching MetadataReader per Spring Resource handle
(i.e. |
CallableStatementCallback<T> | Generic callback interface for code that operates on a CallableStatement. |
CallableStatementCreator | One of the three central callback interfaces used by the JdbcTemplate class. |
CallableStatementCreatorFactory | Helper class that efficiently creates multiple CallableStatementCreator
objects with different parameters based on a SQL statement and a single
set of parameter declarations. |
CallbackPreferringPlatformTransactionManager | Extension of the PlatformTransactionManager
interface, exposing a method for executing a given callback within a transaction. |
CallMetaDataContext | Class to manage context metadata used for the configuration and execution of the call. |
CallMetaDataProvider | Interface specifying the API to be implemented by a class providing call metadata. |
CallMetaDataProviderFactory | Factory used to create a CallMetaDataProvider implementation based on the type of databse being used. |
CallParameterMetaData | Holder of metadata for a specific parameter that is used for call processing. |
CancellableFormController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
CannotAcquireLockException | Exception thrown on failure to aquire a lock during an update, for example during a "select for update" statement. |
CannotCreateRecordException | Exception thrown when the creating of a CCI Record failed for connector-internal reasons. |
CannotCreateTransactionException | Exception thrown when a transaction can't be created using an underlying transaction API such as JTA. |
CannotGetCciConnectionException | Fatal exception thrown when we can't connect to an EIS using CCI. |
CannotGetJdbcConnectionException | Fatal exception thrown when we can't connect to an RDBMS using JDBC. |
CannotLoadBeanClassException | Exception thrown when the BeanFactory cannot load the specified class of a given bean. |
CannotReadScriptException | Thrown by ResourceDatabasePopulator if one of its SQL scripts could
not be read during population. |
CannotSerializeTransactionException | Exception thrown on failure to complete a transaction in serialized mode due to update conflicts. |
CastorMappingException | Exception thrown by CastorMarshaller whenever it encounters a mapping problem. |
CastorMarshaller | Implementation of the Marshaller interface for Castor. |
CciDaoSupport | Convenient super class for CCI-based data access objects. |
CciLocalTransactionManager | PlatformTransactionManager implementation
that manages local transactions for a single CCI ConnectionFactory. |
CciOperationNotSupportedException | Exception thrown when the connector doesn't support a specific CCI operation. |
CciOperations | Interface that specifies a basic set of CCI operations on an EIS. |
CciTemplate | This is the central class in the CCI core package. |
CglibSubclassingInstantiationStrategy | Default object instantiation strategy for use in BeanFactories. |
ChainedExceptionListener | Implementation of the JMS ExceptionListener interface that supports chaining, allowing the addition of multiple ExceptionListener instances in order. |
ChainedPersistenceExceptionTranslator | Implementation of PersistenceExceptionTranslator that supports chaining,
allowing the addition of PersistenceExceptionTranslator instances in order. |
CharacterEditor | Editor for a java.lang.Character, to populate a property
of type Character or char from a String value. |
CharacterEncodingFilter | Servlet 2.3/2.4 Filter that allows one to specify a character encoding for requests. |
CharArrayPropertyEditor | Editor for char arrays. |
CharsetEditor | Editor for java.nio.charset.Charset |
CheckboxesTag | Databinding-aware JSP tag for rendering multiple HTML 'input '
elements with a 'type ' of 'checkbox '. |
CheckboxTag | Databinding-aware JSP tag for rendering an HTML 'input '
element with a 'type ' of 'checkbox '. |
ChildBeanDefinition | Bean definition for beans which inherit settings from their parent. |
ClassArrayEditor | Property editor for an array of java.lang.Class Classes, to enable
the direct population of a Class[] property without having to
use a String class name property as bridge. |
ClassEditor | Property editor for java.lang.Class java.lang.Class, to enable the direct
population of a Class property without recourse to having to use a
String class name property as bridge. |
ClassFilter | Filter that restricts matching of a pointcut or introduction to a given set of target classes. |
ClassFilters | Static utility methods for composing
ClassFilters . |
ClassMetadata | Interface that defines abstract metadata of a specific class, in a form that does not require that class to be loaded yet. |
ClassNameBeanWiringInfoResolver | Simple default implementation of the BeanWiringInfoResolver interface,
looking for a bean with the same name as the fully-qualified class name. |
ClassPathBeanDefinitionScanner | A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry (BeanFactory or ApplicationContext). |
ClassPathResource | Resource implementation for class path resources. |
ClassPathScanningCandidateComponentProvider | A component provider that scans the classpath from a base package. |
ClassPathXmlApplicationContext | Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g. |
ClassRelativeResourceLoader | ResourceLoader implementation that interprets plain resource paths
as relative to a given java.lang.Class . |
ClassUtils | Miscellaneous class utility methods. |
CleanupFailureDataAccessException | Exception thrown when we couldn't cleanup after a data access operation, but the actual operation went OK. |
ClientHttpRequest | Represents a client-side HTTP request. |
ClientHttpRequestExecution | Represents the context of a client-side HTTP request execution. |
ClientHttpRequestFactory | Factory for ClientHttpRequest objects. |
ClientHttpRequestInterceptor | Intercepts client-side HTTP requests. |
ClientHttpResponse | Represents a client-side HTTP response. |
ClobStringType | Hibernate UserType implementation for Strings that get mapped to CLOBs. |
ClobStringTypeHandler | iBATIS TypeHandler implementation for Strings that get mapped to CLOBs. |
CodebaseAwareObjectInputStream | Special ObjectInputStream subclass that falls back to a specified codebase to load classes from if not found locally. |
CollectionFactory | Factory for collections, being aware of Java 5 and Java 6 collections. |
CollectionUtils | Miscellaneous collection utility methods. |
ColumnMapRowMapper | RowMapper implementation that creates a java.util.Map
for each row, representing all columns as key-value pairs: one
entry for each column, with the column name as key. |
CommAreaRecord | CCI Record implementation for a COMMAREA, holding a byte array. |
CommonAnnotationBeanPostProcessor | BeanPostProcessor implementation
that supports common Java annotations out of the box, in particular the JSR-250
annotations in the javax.annotation package. |
CommonAnnotationBeanPostProcessor.LookupElement | Class representing generic injection information about an annotated field or setter method, supporting @Resource and related annotations. |
CommonsClientHttpRequestFactory | ClientHttpRequestFactory implementation that uses
Jakarta Commons HttpClient to create requests. |
CommonsDbcpNativeJdbcExtractor | Implementation of the NativeJdbcExtractor interface for the
Jakarta Commons DBCP connection pool, version 1.1 or higher. |
CommonsFileUploadSupport | Base class for multipart resolvers that use Jakarta Commons FileUpload 1.2 or above. |
CommonsFileUploadSupport.MultipartParsingResult | Holder for a Map of Spring MultipartFiles and a Map of multipart parameters. |
CommonsHttpInvokerRequestExecutor | HttpInvokerRequestExecutor implementation that uses
Jakarta Commons HttpClient
to execute POST requests. |
CommonsLogFactoryBean | Factory bean for commons-logging org.apache.commons.logging.Log instances. |
CommonsLoggingLogSystem | Velocity LogSystem implementation for Jakarta Commons Logging. |
CommonsLogWriter | java.io.Writer adapter for a Commons Logging Log . |
CommonsMultipartFile | MultipartFile implementation for Jakarta Commons FileUpload. |
CommonsMultipartResolver | Servlet-based MultipartResolver implementation
for Jakarta Commons FileUpload
1.2 or above. |
CommonsPoolTargetSource | TargetSource implementation that holds objects in a configurable Jakarta Commons Pool. |
CommonsPortletMultipartResolver | PortletMultipartResolver implementation for
Jakarta Commons FileUpload
1.2 or above. |
CommonsRequestLoggingFilter | Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log. |
ComparableComparator<T extends Comparable<T>> | Comparator that adapts Comparables to the Comparator interface. |
Component | Indicates that an annotated class is a "component". |
ComponentControllerSupport | This class is deprecated. as of Spring 3.0 |
ComponentDefinition | Interface that describes the logical view of a set of BeanDefinitions
and BeanReferences as presented in some configuration context. |
ComponentRegistrar | TODO SPR-7420: document |
ComponentRegistrarAdapter | TODO SPR-7420: document
Adapter is necessary as opposed to having ParserContext implement ComponentRegistrar directly due to tooling issues. |
ComponentScan | Configures component scanning directives for use with @Configuration
classes. |
ComponentScan.Filter | Declares the type filter to be used as an ComponentScan#includeFilters() include filter or ComponentScan#includeFilters() exclude filter. |
ComponentScanBeanDefinitionParser | Parser for the <context:component-scan/> element. |
ComponentScanSpec | Specifies the configuration of Spring's component-scanning feature. |
ComposablePointcut | Convenient class for building up pointcuts. |
CompositeCacheDefinitionSource | Composite CacheDefinitionSource implementation that iterates
over a given array of CacheDefinitionSource instances. |
CompositeCacheManager | Composite CacheManager implementation that iterates
over a given collection of CacheManager instances. |
CompositeComponentDefinition | ComponentDefinition implementation that holds one or more nested
ComponentDefinition instances, aggregating them into a named group
of components. |
CompositeIterator<E> | Iterator that combines multiple other iterators. |
CompositeStringExpression | Represents a template expression broken into pieces. |
CompositeTransactionAttributeSource | Composite TransactionAttributeSource implementation that iterates
over a given array of TransactionAttributeSource instances. |
CompoundComparator<T> | A comparator that chains a sequence of one or more more Comparators. |
CompoundExpression | Represents a DOT separated expression sequence, such as 'property1.property2.methodOne()' |
ConcurrencyFailureException | Exception thrown on concurrency failure. |
ConcurrencyThrottleInterceptor | Interceptor that throttles concurrent access, blocking invocations if a specified concurrency limit is reached. |
ConcurrencyThrottleSupport | Support class for throttling concurrent access to a specific resource. |
ConcurrentCache<K, V> | Simple Cache implementation based on the JDK 1.5+
java.util.concurrent package. |
ConcurrentCacheFactoryBean<K, V> | Factory bean for easy configuration of ConcurrentCache through Spring. |
ConcurrentExecutorAdapter | Adapter that exposes the java.util.concurrent.Executor interface
for any Spring TaskExecutor . |
ConcurrentMap | This interface is deprecated. as of Spring 3.0, since standard java.util.concurrent.ConcurrentMap is available on Java 5+ anyway |
ConcurrentTaskExecutor | Adapter that takes a JSR-166 backport
edu.emory.mathcs.backport.java.util.concurrent.Executor and
exposes a Spring TaskExecutor for it. |
ConcurrentTaskExecutor | Adapter that takes a JDK 1.5 java.util.concurrent.Executor and
exposes a Spring TaskExecutor for it. |
ConcurrentTaskScheduler | Adapter that takes a JDK 1.5 java.util.concurrent.ScheduledExecutorService
and exposes a Spring TaskScheduler for it. |
ConditionalGenericConverter | A generic converter that conditionally executes. |
ConditionalTestCase |
This class is deprecated.
as of Spring 3.0, in favor of using the listener-based test context framework
(AbstractJUnit38SpringContextTests )
|
Configurable | Marks a class as being eligible for Spring-driven configuration. |
ConfigurableApplicationContext | SPI interface to be implemented by most if not all application contexts. |
ConfigurableBeanFactory | Configuration interface to be implemented by most bean factories. |
ConfigurableEnvironment | Configuration interface to be implemented by most if not all Environments . |
ConfigurableJasperReportsView | Configurable JasperReports View, allowing to specify the JasperReports exporter to be specified through bean properties rather than through the view class name. |
ConfigurableListableBeanFactory | Configuration interface to be implemented by most listable bean factories. |
ConfigurableMimeFileTypeMap | Spring-configurable FileTypeMap implementation that will read
MIME type to file extension mappings from a standard JavaMail MIME type
mapping file, using a standard MimetypesFileTypeMap underneath. |
ConfigurableObject | Marker interface for domain object that need DI through aspects. |
ConfigurableObjectInputStream | Special ObjectInputStream subclass that resolves class names against a specific ClassLoader. |
ConfigurablePortletApplicationContext | Interface to be implemented by configurable portlet application contexts. |
ConfigurablePropertyAccessor | Interface that encapsulates configuration methods for a PropertyAccessor. |
ConfigurablePropertyResolver | Configuration interface to be implemented by most if not all PropertyResolvers . |
ConfigurableWebApplicationContext | Interface to be implemented by configurable web application contexts. |
ConfigurableWebBindingInitializer | Convenient WebBindingInitializer for declarative configuration
in a Spring application context. |
Configuration | Indicates that a class declares one or more Bean methods and may be processed
by the Spring container to generate bean definitions and service requests for those beans
at runtime. |
ConfigurationClassPostProcessor | BeanFactoryPostProcessor used for bootstrapping processing of
@Configuration classes. |
ConnectionCallback<T> | Generic callback interface for code that operates on a CCI Connection. |
ConnectionCallback<T> | Generic callback interface for code that operates on a JDBC Connection. |
ConnectionFactoryUtils | Helper class that provides static methods for obtaining CCI Connections from a javax.resource.cci.ConnectionFactory. |
ConnectionFactoryUtils | Helper class for managing a JMS javax.jms.ConnectionFactory, in particular for obtaining transactional JMS resources for a given ConnectionFactory. |
ConnectionFactoryUtils.ResourceFactory | Callback interface for resource creation. |
ConnectionHandle | Simple interface to be implemented by handles for a JDBC Connection. |
ConnectionHolder | Connection holder, wrapping a CCI Connection. |
ConnectionHolder | Connection holder, wrapping a JDBC Connection. |
ConnectionProperties | DataSourceFactory helper that allows essential JDBC connection properties to be configured consistently, independent of the actual DataSource implementation. |
ConnectionProxy | Subinterface of java.sql.Connection to be implemented by Connection proxies. |
ConnectionSpecConnectionFactoryAdapter | An adapter for a target CCI javax.resource.cci.ConnectionFactory,
applying the given ConnectionSpec to every standard getConnection()
call, that is, implicitly invoking getConnection(ConnectionSpec)
on the target. |
ConnectorServerFactoryBean | FactoryBean that creates a JSR-160 JMXConnectorServer,
optionally registers it with the MBeanServer and then starts it. |
ConstantException | Exception thrown when the Constants class is asked for
an invalid constant name. |
Constants | This class can be used to parse other classes containing constant definitions in public static final members. |
ConstructorArgumentEntry | ParseState entry representing a (possibly indexed)
constructor argument. |
ConstructorArgumentValues | Holder for constructor argument values, typically as part of a bean definition. |
ConstructorArgumentValues.ValueHolder | Holder for a constructor argument value, with an optional type attribute indicating the target type of the actual constructor argument. |
ConstructorExecutor | Executors are built by resolvers and can be cached by the infrastructure to repeat an operation quickly without going back to the resolvers. |
ConstructorReference | Represents the invocation of a constructor. |
ConstructorResolver | A constructor resolver attempts locate a constructor and returns a ConstructorExecutor that can be used to invoke that constructor. |
ContentNegotiatingViewResolver | Implementation of ViewResolver that resolves a view based on the request file name or Accept header. |
ContextBeanFactoryReference | ApplicationContext-specific implementation of BeanFactoryReference, wrapping a newly created ApplicationContext, closing it on release. |
ContextCleanupListener | Web application listener that cleans up remaining disposable attributes in the ServletContext, i.e. |
ContextClosedEvent | Event raised when an ApplicationContext gets closed. |
ContextConfiguration | ContextConfiguration defines class-level metadata which can be used to
instruct client code with regard to how to load and configure an
ApplicationContext . |
ContextExposingHttpServletRequest | HttpServletRequest decorator that makes all Spring beans in a given WebApplicationContext accessible as request attributes, through lazy checking once an attribute gets accessed. |
ContextJndiBeanFactoryLocator | BeanFactoryLocator implementation that creates the BeanFactory from one or more classpath locations specified in a JNDI environment variable. |
ContextLoader | Strategy interface for loading an
application context . |
ContextLoader | Performs the actual initialization work for the root application context. |
ContextLoaderListener | Bootstrap listener to start up and shut down Spring's root WebApplicationContext . |
ContextLoaderPlugIn | This class is deprecated. as of Spring 3.0 |
ContextNamespaceHandler | NamespaceHandler
for the 'context ' namespace. |
ContextRefreshedEvent | Event raised when an ApplicationContext gets initialized or refreshed. |
ContextResource | Extended interface for a resource that is loaded from an enclosing 'context', e.g. |
ContextSingletonBeanFactoryLocator | Variant of |
ContextStartedEvent | Event raised when an ApplicationContext gets started. |
ContextStoppedEvent | Event raised when an ApplicationContext gets stopped. |
ControlFlow | Interface to be implemented by objects that can return information about the current call stack. |
ControlFlowFactory | Static factory to conceal the automatic choice of the ControlFlow implementation class. |
ControlFlowPointcut | Pointcut and method matcher for use in simple cflow-style pointcut. |
Controller | Indicates that an annotated class is a "Controller" (e.g. |
Controller | Base portlet Controller interface, representing a component that receives
RenderRequest/RenderResponse and ActionRequest/ActionResponse like a
Portlet but is able to participate in an MVC workflow. |
Controller | Base Controller interface, representing a component that receives
HttpServletRequest and HttpServletResponse
instances just like a HttpServlet but is able to
participate in an MVC workflow. |
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. |
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. |
Conventions | Provides methods to support various naming and other conventions used throughout the framework. |
ConversionException | Base class for exceptions thrown by the conversion system. |
ConversionFailedException | Exception to be thrown when an actual type conversion attempt fails. |
ConversionNotSupportedException | Exception thrown when no suitable editor or converter can be found for a bean property. |
ConversionService | A service interface for type conversion. |
ConversionServiceExposingInterceptor | Interceptor that places the configured ConversionService in request scope
so it's available during request processing. |
ConversionServiceFactory | A factory for common ConversionService
configurations. |
ConversionServiceFactoryBean | A factory providing convenient access to a ConversionService configured with converters appropriate for most environments. |
Converter<S, T> | A converter converts a source object of type S to a target of type T. |
ConverterFactory<S, R> | A factory for "ranged" converters that can convert objects from S to subtypes of R. |
ConverterNotFoundException | Thrown when a suitable converter could not be found in a conversion service. |
ConverterRegistry | For registering converters with a type conversion system. |
ConvertingPropertyEditorAdapter | Adapter that exposes a java.beans.PropertyEditor for any given
ConversionService and specific target type. |
CookieGenerator | Helper class for cookie generation, carrying cookie descriptor settings as bean properties and being able to add and remove cookie to/from a given response. |
CookieLocaleResolver | LocaleResolver implementation that uses a cookie sent back to the user
in case of a custom setting, with a fallback to the specified default locale
or the request's accept-header locale. |
CookieThemeResolver | Implementation of ThemeResolver that uses a cookie sent back to the user in case of a custom setting, with a fallback to the default theme. |
CookieValue | Annotation which indicates that a method parameter should be bound to an HTTP cookie. |
CronSequenceGenerator | Date sequence generator for a Crontab pattern, allowing clients to specify a pattern that the sequence matches. |
CronTrigger | Trigger implementation for cron expressions. |
CronTriggerBean | Convenience subclass of Quartz's org.quartz.CronTrigger class, making bean-style usage easier. |
CurrencyEditor | Editor for java.util.Currency , translating currency codes into Currency
objects. |
CurrencyFormatter | A BigDecimal formatter for currency values. |
CustomAutowireConfigurer | A BeanFactoryPostProcessor
implementation that allows for convenient registration of custom autowire
qualifier types. |
CustomBooleanEditor | Property editor for Boolean/boolean properties. |
CustomCollectionEditor | Property editor for Collections, converting any source Collection to a given target Collection type. |
CustomDateEditor | Property editor for java.util.Date ,
supporting a custom java.text.DateFormat . |
CustomEditorConfigurer | BeanFactoryPostProcessor implementation that allows for convenient
registration of custom PropertyEditor property editors. |
CustomizableThreadCreator | Simple customizable helper class for creating threads. |
CustomizableThreadFactory | Implementation of the JSR-166 backport edu.emory.mathcs.backport.java.util.concurrent.ThreadFactory interface, allowing for customizing the created threads (name, priority, etc). |
CustomizableThreadFactory | Implementation of the JDK 1.5 java.util.concurrent.ThreadFactory interface, allowing for customizing the created threads (name, priority, etc). |
CustomizableTraceInterceptor | MethodInterceptor implementation that allows for highly customizable
method-level tracing, using placeholders. |
CustomMapEditor | Property editor for Maps, converting any source Map to a given target Map type. |
CustomNumberEditor | Property editor for any Number subclass such as Short, Integer, Long, BigInteger, Float, Double, BigDecimal. |
CustomScopeConfigurer | Simple BeanFactoryPostProcessor implementation that registers
custom Scope(s) with the containing ConfigurableBeanFactory . |
CustomSQLErrorCodesTranslation | JavaBean for holding custom JDBC error codes translation for a particular database. |
CustomValidatorBean | Configurable bean class that exposes a specific JSR-303 Validator
through its original interface as well as through the Spring
Validator interface. |
DaoSupport | Generic base class for DAOs, defining template methods for DAO initialization. |
DataAccessException | Root of the hierarchy of data access exceptions discussed in Expert One-On-One J2EE Design and Development. |
DataAccessResourceFailureException | Data access exception thrown when a resource fails completely: for example, if we can't connect to a database using JDBC. |
DataAccessUtils | Miscellaneous utility methods for DAO implementations. |
Database | Enumeration for common database platforms. |
DatabaseMetaDataCallback | A callback interface used by the JdbcUtils class. |
DatabasePopulator | Strategy used to populate a database during initialization. |
DatabaseStartupValidator | Bean that checks if a database has already started up. |
DataBinder | Binder that allows for setting property values onto a target object, including support for validation and binding result analysis. |
DataFieldMaxValueIncrementer | Interface that defines contract of incrementing any data store field's maximum value. |
DataIntegrityViolationException | Exception thrown when an attempt to insert or update data results in violation of an integrity constraint. |
DataRetrievalFailureException | Exception thrown if certain expected data could not be retrieved, e.g. |
DataSourceFactory | Encapsulates the creation of a particular DataSource implementation, such as a
SimpleDriverDataSource or connection pool such as Apache DBCP or C3P0. |
DataSourceInitializer | Used to populate a database during initialization. |
DataSourceLookup | Strategy interface for looking up DataSources by name. |
DataSourceLookupFailureException | Exception to be thrown by a DataSourceLookup implementation, indicating that the specified DataSource could not be obtained. |
DataSourceTransactionManager | PlatformTransactionManager
implementation for a single JDBC javax.sql.DataSource. |
DataSourceUtils | Helper class that provides static methods for obtaining JDBC Connections from a javax.sql.DataSource. |
DateFormatter | A formatter for java.util.Date types. |
DateTimeFormat | Declares that a field should be formatted as a date time. |
DateTimeFormat.ISO | Common ISO date time format patterns. |
DateTimeParser | Parses Joda Time DateTime instances using a DateTimeFormatter. |
Db2CallMetaDataProvider | DB2 specific implementation for the CallMetaDataProvider interface. |
DB2MainframeSequenceMaxValueIncrementer | DataFieldMaxValueIncrementer that retrieves the next value of a given sequence
on DB2/390 or DB2/400. |
DB2SequenceMaxValueIncrementer | DataFieldMaxValueIncrementer that retrieves the next value of a given sequence
on DB2 UDB (for Unix and Windows). |
DeadlockLoserDataAccessException | Generic exception thrown when the current process was a deadlock loser, and its transaction rolled back. |
DebugInterceptor | AOP Alliance MethodInterceptor that can be introduced in a chain
to display verbose information about intercepted invocations to the logger. |
DeclareParentsAdvisor | Introduction advisor delegating to the given object. |
DecoratingClassLoader | Base class for decorating ClassLoaders such as OverridingClassLoader
and ShadowingClassLoader ,
providing common handling of excluded packages and classes. |
DecoratingNavigationHandler | Base class for JSF NavigationHandler implementations that want to be capable of decorating an original NavigationHandler. |
DefaultAdvisorAdapterRegistry | Default implementation of the AdvisorAdapterRegistry interface. |
DefaultAdvisorAutoProxyCreator | BeanPostProcessor implementation that creates AOP proxies based on all candidate Advisors in the current BeanFactory. |
DefaultAdvisorChainFactory | A simple but definitive way of working out an advice chain for a Method,
given an Advised object. |
DefaultAnnotationHandlerMapping | Implementation of the HandlerMapping
interface that maps handlers based on portlet modes expressed through the
RequestMapping annotation at the type or method level. |
DefaultAnnotationHandlerMapping | Implementation of the HandlerMapping
interface that maps handlers based on HTTP paths expressed through the
RequestMapping annotation at the type or method level. |
DefaultAopProxyFactory | Default AopProxyFactory implementation,
creating either a CGLIB proxy or a JDK dynamic proxy. |
DefaultBeanDefinitionDocumentReader | Default implementation of the BeanDefinitionDocumentReader interface. |
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. |
DefaultBeanNameGenerator | Default implementation of the BeanNameGenerator interface, delegating to
generateBeanName(BeanDefinition, BeanDefinitionRegistry) . |
DefaultBindingErrorProcessor | Default BindingErrorProcessor implementation. |
DefaultCacheExpressionRootObject | Default implementation of expression root object. |
DefaultCacheInvalidateDefinition | Default implementation of the CacheInvalidateDefinition interface. |
DefaultCacheUpdateDefinition | Default implementation of the CacheUpdateDefinition interface. |
DefaultContextLoadTimeWeaver | Default LoadTimeWeaver bean for use in an application context,
decorating an automatically detected internal LoadTimeWeaver . |
DefaultConversionService | A specialization of GenericConversionService configured by default with
converters appropriate for most applications. |
DefaultDeserializer | Deserializer that reads an input stream using Java Serialization. |
DefaultDocumentLoader | Spring's default DocumentLoader implementation. |
DefaultEnvironment | Default implementation of the Environment interface. |
DefaultFormattingConversionService | A specialization of FormattingConversionService configured by default with
converters and formatters appropriate for most applications. |
DefaultHandlerExceptionResolver | Default implementation of the HandlerExceptionResolver interface that resolves standard Spring exceptions and translates
them to corresponding HTTP status codes. |
DefaultIntroductionAdvisor | Simple IntroductionAdvisor implementation
that by default applies to any class. |
DefaultJdoDialect | Default implementation of the JdoDialect interface. |
DefaultJmsActivationSpecFactory | Default implementation of the JmsActivationSpecFactory interface. |
DefaultJpaDialect | Default implementation of the JpaDialect interface. |
DefaultKeyGenerator | Default key generator. |
DefaultLifecycleProcessor | Default implementation of the LifecycleProcessor strategy. |
DefaultListableBeanFactory | Default implementation of the
ListableBeanFactory and
BeanDefinitionRegistry interfaces: a full-fledged bean factory
based on bean definition objects. |
DefaultLobHandler | Default implementation of the LobHandler interface. |
DefaultLobHandler.DefaultLobCreator | Default LobCreator implementation as inner class. |
DefaultLocatorFactory | A factory class to get a default ContextSingletonBeanFactoryLocator instance. |
DefaultMessageCodesResolver | Default implementation of the MessageCodesResolver interface. |
DefaultMessageListenerContainer | Message listener container variant that uses plain JMS client API, specifically
a loop of MessageConsumer.receive() calls that also allow for
transactional reception of messages (registering them with XA transactions). |
DefaultMessageListenerContainer102 |
This class is deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based DefaultMessageListenerContainer
|
DefaultMessageSourceResolvable | Default implementation of the MessageSourceResolvable interface. |
DefaultMultipartActionRequest | Default implementation of the MultipartActionRequest interface. |
DefaultMultipartHttpServletRequest | Default implementation of the
MultipartHttpServletRequest
interface. |
DefaultNamespaceHandlerResolver | Default implementation of the NamespaceHandlerResolver interface. |
DefaultPersistenceUnitManager | Default implementation of the PersistenceUnitManager interface. |
DefaultPointcutAdvisor | Convenient Pointcut-driven Advisor implementation. |
DefaultPortletEnvironment | Environment implementation to be used by Servlet -based web
applications. |
DefaultPropertiesPersister | Default implementation of the PropertiesPersister interface. |
DefaultRemoteInvocationExecutor | Default implementation of the RemoteInvocationExecutor interface. |
DefaultRemoteInvocationFactory | Default implementation of the RemoteInvocationFactory interface. |
DefaultRequestToViewNameTranslator | RequestToViewNameTranslator
that simply transforms the URI of the incoming request into a view name. |
DefaultResourceLoader | Default implementation of the ResourceLoader interface. |
DefaultResponseErrorHandler | Default implementation of the ResponseErrorHandler interface. |
DefaultScopedObject | Default implementation of the ScopedObject interface. |
DefaultsDefinition | Marker interface for a defaults definition, extending BeanMetadataElement to inherit source exposure. |
DefaultSerializer | Serializer that writes an object to an output stream using Java Serialization. |
DefaultServletHttpRequestHandler | An HttpRequestHandler for serving static files using the Servlet container's "default" Servlet. |
DefaultSessionAttributeStore | Default implementation of the SessionAttributeStore interface,
storing the attributes in the WebRequest session (i.e. |
DefaultSingletonBeanRegistry | Generic registry for shared bean instances, implementing the
SingletonBeanRegistry . |
DefaultToStringStyler | Spring's default toString() styler. |
DefaultTransactionAttribute | Transaction attribute that takes the EJB approach to rolling back on runtime, but not checked, exceptions. |
DefaultTransactionDefinition | Default implementation of the TransactionDefinition interface,
offering bean-style configuration and sensible default values
(PROPAGATION_REQUIRED, ISOLATION_DEFAULT, TIMEOUT_DEFAULT, readOnly=false). |
DefaultTransactionStatus | Default implementation of the TransactionStatus
interface, used by AbstractPlatformTransactionManager . |
DefaultValueStyler | Converts objects to String form, generally for debugging purposes,
using Spring's toString styling conventions. |
DefaultWebEnvironment | Environment implementation to be used by Servlet -based web
applications. |
DelegatePerTargetObjectIntroductionInterceptor | Convenient implementation of the
IntroductionInterceptor interface. |
DelegatingActionProxy | This class is deprecated. as of Spring 3.0 |
DelegatingActionUtils | This class is deprecated. as of Spring 3.0 |
DelegatingConnectionFactory | CCI ConnectionFactory implementation that delegates all calls to a given target ConnectionFactory. |
DelegatingConnectionFactory | javax.jms.ConnectionFactory implementation that delegates all calls
to a given target javax.jms.ConnectionFactory, adapting specific
create(Queue/Topic)Connection calls to the target ConnectionFactory
if necessary (e.g. |
DelegatingDataSource | JDBC javax.sql.DataSource implementation that delegates all calls to a given target javax.sql.DataSource. |
DelegatingEntityResolver | EntityResolver implementation that delegates to a BeansDtdResolver
and a PluggableSchemaResolver for DTDs and XML schemas, respectively. |
DelegatingErrorHandlingRunnable | Runnable wrapper that catches any exception or error thrown from its
delegate Runnable and allows an ErrorHandler to handle it. |
DelegatingFilterProxy | Proxy for a standard Servlet 2.3 Filter, delegating to a Spring-managed bean that implements the Filter interface. |
DelegatingIntroductionInterceptor | Convenient implementation of the
IntroductionInterceptor interface. |
DelegatingJob | Simple Quartz org.quartz.Job adapter that delegates to a given java.lang.Runnable instance. |
DelegatingMessageSource | Empty MessageSource that delegates all calls to the parent MessageSource. |
DelegatingNavigationHandlerProxy | JSF NavigationHandler implementation that delegates to a NavigationHandler bean obtained from the Spring root WebApplicationContext. |
DelegatingPhaseListenerMulticaster | JSF PhaseListener implementation that delegates to one or more Spring-managed PhaseListener beans coming from the Spring root WebApplicationContext. |
DelegatingRequestProcessor | This class is deprecated. as of Spring 3.0 |
DelegatingServletInputStream | Delegating implementation of javax.servlet.ServletInputStream. |
DelegatingServletOutputStream | Delegating implementation of javax.servlet.ServletOutputStream. |
DelegatingThemeSource | Empty ThemeSource that delegates all calls to the parent ThemeSource. |
DelegatingTilesRequestProcessor | This class is deprecated. as of Spring 3.0 |
DelegatingTimerListener | Simple TimerListener adapter that delegates to a given Runnable. |
DelegatingTimerTask |
This class is deprecated.
as of Spring 3.0, in favor of the scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService
|
DelegatingTransactionAttribute | TransactionAttribute implementation that delegates all calls to a given target
TransactionAttribute instance. |
DelegatingTransactionDefinition | TransactionDefinition implementation that delegates all calls to a given target
TransactionDefinition instance. |
DelegatingVariableResolver | JSF 1.1 VariableResolver that first delegates to the
original resolver of the underlying JSF implementation (for resolving
managed-bean objects as defined in faces-config.xml
as well as well-known implicit EL attributes), then to the Spring
root WebApplicationContext (for resolving Spring beans). |
DelegatingWork | Simple Work adapter that delegates to a given Runnable. |
DelegatingWork | Simple Work adapter that delegates to a given Runnable. |
DependencyDescriptor | Descriptor for a specific dependency that is about to be injected. |
DependencyInjectionTestExecutionListener | TestExecutionListener which provides support for dependency
injection and initialization of test instances. |
DependsOn | Beans on which the current bean depends. |
DeprecatedBeanWarner | Bean factory post processor that logs a warning for Deprecated @Deprecated beans. |
DerbyCallMetaDataProvider | Derby specific implementation for the CallMetaDataProvider interface. |
DerbyMaxValueIncrementer | DataFieldMaxValueIncrementer that increments the maximum value of a given Derby table
with the equivalent of an auto-increment column. |
DerbyTableMetaDataProvider | The Derby specific implementation of the TableMetaDataProvider . |
DescriptiveResource | Simple Resource implementation that holds a resource description
but does not point to an actually readable resource. |
Deserializer<T> | A strategy interface for converting from data in an InputStream to an Object. |
DeserializingConverter | A Converter that delegates to a Deserializer
to convert data in a byte array to an object. |
DestinationResolutionException | Thrown by a DestinationResolver when it cannot resolve a destination name. |
DestinationResolver | Strategy interface for resolving JMS destinations. |
DestructionAwareBeanPostProcessor | Subinterface of BeanPostProcessor that adds a before-destruction callback. |
DestructionCallbackBindingListener | Adapter that implements the Servlet 2.3 HttpSessionBindingListener interface, wrapping a session destruction callback. |
DigestUtils | Miscellaneous methods for calculating digests. |
DirectFieldAccessor | PropertyAccessor implementation that directly accesses instance fields. |
DirectFieldBindingResult | Special implementation of the Errors and BindingResult interfaces, supporting registration and evaluation of binding errors on value objects. |
DirtiesContext | Test annotation which indicates that the
ApplicationContext
associated with a test is dirty and should be closed:
Use this annotation if a test has modified the context (for example, by replacing a bean definition). |
DirtiesContext.ClassMode | Defines modes which determine how @DirtiesContext
is interpreted when used to annotate a test class. |
DirtiesContextTestExecutionListener | TestExecutionListener which provides support for marking the
ApplicationContext associated with a test as dirty for
both test classes and test methods configured with the @DirtiesContext annotation. |
DispatchActionSupport | This class is deprecated. as of Spring 3.0 |
DispatcherPortlet | Central dispatcher for use within the Portlet MVC framework, e.g. |
DispatcherServlet | Central dispatcher for HTTP request handlers/controllers, e.g. |
DispatcherServletWebRequest | ServletWebRequest subclass that is aware of
DispatcherServlet 's
request context, such as the Locale determined by the configured
LocaleResolver . |
DisposableBean | Interface to be implemented by beans that want to release resources on destruction. |
DisposableSqlTypeValue | Subinterface of SqlTypeValue that adds a cleanup callback,
to be invoked after the value has been set and the corresponding
statement has been executed. |
DocumentDefaultsDefinition | Simple JavaBean that holds the defaults specified at the <beans>
level in a standard Spring XML bean definition document:
default-lazy-init , default-autowire , etc. |
DocumentLoader | Strategy interface for loading an XML Document. |
DomUtils | Convenience methods for working with the DOM API, in particular for working with DOM Nodes and DOM Elements. |
DriverManagerDataSource | Simple implementation of the standard JDBC javax.sql.DataSource interface,
configuring the plain old JDBC java.sql.DriverManager via bean properties, and
returning a new java.sql.Connection from every getConnection call. |
DuplicateKeyException | Exception thrown when an attempt to insert or update data results in violation of an primary key or unique constraint. |
DynamicDestinationResolver | Simple DestinationResolver implementation resolving destination names
as dynamic destinations. |
DynamicIntroductionAdvice | Subinterface of AOP Alliance Advice that allows additional interfaces to be implemented by an Advice, and available via a proxy using that interceptor. |
DynamicMethodMatcher | Convenient abstract superclass for dynamic method matchers, which do care about arguments at runtime. |
DynamicMethodMatcherPointcut | Convenient superclass when we want to force subclasses to implement MethodMatcher interface, but subclasses will want to be pointcuts. |
EarlyBeanReferenceProxy | Marker interface indicating that an object is a proxy for a bean referenced
from within a @Feature method. |
EclipseLinkJpaDialect | JpaDialect implementation for Eclipse
Persistence Services (EclipseLink). |
EclipseLinkJpaVendorAdapter | JpaVendorAdapter implementation for Eclipse
Persistence Services (EclipseLink). |
EditorAwareTag | Interface to be implemented by JSP tags that expose a PropertyEditor for a property that they are currently bound to. |
EhCacheCache | Cache implementation on top of an Ehcache instance. |
EhCacheCacheManager | CacheManager backed by an Ehcache net.sf.ehcache.CacheManager. |
EhCacheFactoryBean | FactoryBean that creates a named EHCache net.sf.ehcache.Cache instance
(or a decorator that implements the net.sf.ehcache.Ehcache interface),
representing a cache region within an EHCache net.sf.ehcache.CacheManager. |
EhCacheManagerFactoryBean | FactoryBean that exposes an EHCache net.sf.ehcache.CacheManager
instance (independent or shared), configured from a specified config location. |
EisOperation | Base class for EIS operation objects that work with the CCI API. |
Ejb3TransactionAnnotationParser | Strategy implementation for parsing EJB3's javax.ejb.TransactionAttribute annotation. |
EjbAccessException | Exception that gets thrown when an EJB stub cannot be accessed properly. |
Elvis | Represents the elvis operator ?:. |
EmbeddedDatabase | A handle to an EmbeddedDatabase instance. |
EmbeddedDatabaseBuilder | A builder that provides a fluent API for constructing an embedded database. |
EmbeddedDatabaseConfigurer | Encapsulates the configuration required to create, connect to, and shutdown a specific type of embedded database such as HSQL or H2. |
EmbeddedDatabaseFactory | Creates a EmbeddedDatabase instance. |
EmbeddedDatabaseFactoryBean | A subclass of EmbeddedDatabaseFactory that implements FactoryBean for registration as a Spring bean. |
EmbeddedDatabaseType | A supported embedded database type. |
EmbeddedValueResolverAware | Interface to be implemented by any object that wishes to be notified of a StringValueResolver for the resolution of embedded definition values. |
EmptyReaderEventListener | Empty implementation of the ReaderEventListener interface,
providing no-op implementations of all callback methods. |
EmptyResultDataAccessException | Data access exception thrown when a result was expected to have at least one row (or element) but zero rows (or elements) were actually returned. |
EmptyTargetSource | Canonical TargetSource when there is no target
(or just the target class known), and behavior is supplied
by interfaces and advisors only. |
EncodedResource | Holder that combines a Resource
with a specific encoding to be used for reading from the resource. |
EntityManagerFactoryAccessor | Base class for any class that needs to access an EntityManagerFactory, usually in order to obtain an EntityManager. |
EntityManagerFactoryInfo | Metadata interface for a Spring-managed JPA EntityManagerFactory. |
EntityManagerFactoryPlus | Extension of the standard JPA EntityManagerFactory interface, linking in Spring's EntityManagerFactoryPlusOperations interface which defines additional operations (beyond JPA 1.0) in a vendor-independent fashion. |
EntityManagerFactoryPlusOperations | Interface that defines common operations beyond the standard JPA EntityManagerFactory interface, in a vendor-independent fashion. |
EntityManagerFactoryUtils | Helper class featuring methods for JPA EntityManager handling, allowing for reuse of EntityManager instances within transactions. |
EntityManagerHolder | Holder wrapping a JPA EntityManager. |
EntityManagerPlus | Extension of the standard JPA EntityManager interface, linking in Spring's EntityManagerPlusOperations interface which defines additional operations (beyond JPA 1.0) in a vendor-independent fashion. |
EntityManagerPlusOperations | Interface that defines common operations beyond the standard JPA EntityManager interface, in a vendor-independent fashion. |
EntityManagerProxy | Subinterface of javax.persistence.EntityManager to be implemented by EntityManager proxies. |
EnumerablePropertySource<T> | TODO SPR-7508: document |
Environment | Interface representing the environment in which the current application is running. |
EnvironmentAccessor | Read-only EL property accessor that knows how to retrieve keys
of a Spring Environment instance. |
EnvironmentAware | Interface to be implemented by any bean that wishes to be notified
of the Environment that it runs in. |
EnvironmentCapable | Interface indicating a component contains and makes available an Environment object. |
ErrorCoded | Interface that can be implemented by exceptions etc that are error coded. |
ErrorHandler | A strategy for handling errors. |
Errors | Stores and exposes information about data-binding and validation errors for a specific object. |
ErrorsTag | Form tag for displaying errors for a particular field or object. |
EscapeBodyTag | Custom JSP tag to escape its enclosed body content, applying HTML escaping and/or JavaScript escaping. |
EscapedErrors | Errors wrapper that adds automatic HTML escaping to the wrapped instance, for convenient usage in HTML views. |
EvalTag | JSP tag for evaluating expressions with the Spring Expression Language (SpEL). |
EvaluationContext | Expressions are executed in an evaluation context. |
EvaluationException | Represent an exception that occurs during expression evaluation. |
EventAwareController | Extension of the Portlet Controller interface that allows
for handling Portlet 2.0 event requests as well. |
EventMapping | Annotation for mapping Portlet event requests onto handler methods. |
EventPublicationInterceptor | MethodInterceptor Interceptor that publishes an
ApplicationEvent to all ApplicationListeners
registered with an ApplicationEventPublisher after each
successful method invocation. |
ExceptionDepthComparator | Comparator capable of sorting exceptions based on their depth from the thrown exception type. |
ExceptionHandler | Annotation for handling exceptions in specific handler classes and/or handler methods. |
ExecutorBeanDefinitionParser | Parser for the 'executor' element of the 'task' namespace. |
ExecutorConfigurationSupport | Base class for classes that are setting up a
java.util.concurrent.ExecutorService
(typically a java.util.concurrent.ThreadPoolExecutor). |
ExecutorServiceAdapter | Adapter that takes a Spring TaskExecutor )
and exposes a full java.util.concurrent.ExecutorService for it. |
ExpectedException | Test annotation to indicate that a test method is required to throw the specified exception. |
ExpectedLookupTemplate | Simple extension of the JndiTemplate class that always returns a given object. |
ExposeBeanNameAdvisors | Convenient methods for creating advisors that may be used when autoproxying beans created with the Spring IoC container, binding the bean name to the current invocation. |
ExposeInvocationInterceptor | Interceptor that exposes the current org.aopalliance.intercept.MethodInvocation as a thread-local object. |
Expression | An expression capable of evaluating itself against context objects. |
ExpressionEvaluationUtils | Convenience methods for accessing JSP 2.0's javax.servlet.jsp.el.ExpressionEvaluator. |
ExpressionException | Super class for exceptions that can occur whilst processing expressions |
ExpressionInvocationTargetException | This exception wraps (as cause) a checked exception thrown by some method that SpEL invokes. |
ExpressionParser | Parses expression strings into compiled expressions that can be evaluated. |
ExpressionPointcut | Interface to be implemented by pointcuts that use String expressions. |
ExpressionState | An ExpressionState is for maintaining per-expression-evaluation state, any changes to it are not seen by other expressions but it gives a place to hold local variables and for component expressions in a compound expression to communicate state. |
ExpressionUtils | Common utility functions that may be used by any Expression Language provider. |
ExtendedEntityManagerCreator | Factory for dynamic EntityManager proxies that follow the JPA spec's semantics for "extended" EntityManagers. |
ExtendedModelMap | Subclass of ModelMap that implements the Model interface. |
FacesContextUtils | Convenience methods to retrieve the root WebApplicationContext for a given FacesContext. |
FacesRequestAttributes | RequestAttributes adapter for a JSF javax.faces.context.FacesContext. |
FacesWebRequest | WebRequest adapter for a JSF javax.faces.context.FacesContext. |
FactoryBean<T> | Interface to be implemented by objects used within a BeanFactory
which are themselves factories. |
FactoryBeanNotInitializedException | Exception to be thrown from a FactoryBean's getObject() method
if the bean is not fully initialized yet, for example because it is involved
in a circular reference. |
FactoryBeanRegistrySupport | Support base class for singleton registries which need to handle
FactoryBean instances,
integrated with DefaultSingletonBeanRegistry 's singleton management. |
FailFastProblemReporter | Simple ProblemReporter implementation that exhibits fail-fast
behavior when errors are encountered. |
FatalBeanException | Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g. |
Feature | TODO SPR-7420: document |
FeatureAnnotation | Meta-annotation indicating that an annotation should be processed
to produce a FeatureSpecification . |
FeatureAnnotationParser | Interface for parsing AnnotationMetadata from a FeatureAnnotation
into a FeatureSpecification object. |
FeatureConfiguration | TODO SPR-7420: document |
FeatureSpecification | Interface to be implemented by objects that specify the configuration of a particular feature of the Spring container e.g., component-scanning, JMX MBean exporting, AspectJ auto-proxying, annotation-driven transaction management, and so on. |
FeatureSpecificationExecutor | Interface for executing a populated FeatureSpecification . |
FieldError | Encapsulates a field error, that is, a reason for rejecting a specific field value. |
FieldRetrievingFactoryBean | FactoryBean which retrieves a static or non-static field value. |
FileCopyUtils | Simple utility methods for file and stream copying. |
FileEditor | Editor for java.io.File , to directly populate a File property
from a Spring resource location. |
FileSystemResource | Resource implementation for java.io.File handles. |
FileSystemResourceLoader | ResourceLoader implementation that resolves plain paths as
file system resources rather than as class path resources
(the latter is DefaultResourceLoader 's default strategy). |
FileSystemUtils | Utility methods for working with the file system. |
FileSystemXmlApplicationContext | Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g. |
FilterDefinitionFactoryBean | Convenient FactoryBean for defining Hibernate FilterDefinitions. |
FilterType | Enumeration of the type filters that may be used in conjunction with
@ComponentScan . |
FixedLocaleResolver | LocaleResolver implementation
that always returns a fixed default locale. |
FixedThemeResolver | Implementation of ThemeResolver that simply uses a fixed theme. |
FormatHelper | Utility methods (formatters, etc) used during parsing and evaluation. |
Formatter<T> | Formats objects of type T. |
FormatterRegistrar | Registers Converters and Formatters with
a FormattingConversionService through the FormatterRegistry SPI. |
FormatterRegistry | A registry of field formatting logic. |
FormattingConversionService | A ConversionService implementation
designed to be configured as a FormatterRegistry . |
FormattingConversionServiceFactoryBean | A factory providing convenient access to a FormattingConversionService
configured with converters and formatters for common types such as numbers and
datetimes. |
FormHttpMessageConverter | Implementation of HttpMessageConverter that can handle form data, including multipart form data (i.e. |
FormTag | Databinding-aware JSP tag for rendering an HTML 'form ' whose
inner elements are bound to properties on a form object. |
FrameworkPortlet | Base portlet for Spring's portlet framework. |
FrameworkServlet | Base servlet for Spring's web framework. |
FreeMarkerConfig | Interface to be implemented by objects that configure and manage a FreeMarker Configuration object in a web environment. |
FreeMarkerConfigurationFactory | Factory that configures a FreeMarker Configuration. |
FreeMarkerConfigurationFactoryBean | Factory bean that creates a FreeMarker Configuration and provides it as bean reference. |
FreeMarkerConfigurer | JavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties. |
FreeMarkerTemplateUtils | Utility class for working with FreeMarker. |
FreeMarkerView | View using the FreeMarker template engine. |
FreeMarkerViewResolver | Convenience subclass of UrlBasedViewResolver
that supports FreeMarkerView (i.e. |
FunctionReference | A function reference is of the form "#someFunction(a,b,c)". |
GeneratedKeyHolder | Default implementation of the KeyHolder interface, to be used for
holding auto-generated keys (as potentially returned by JDBC insert statements). |
GenericApplicationContext | Generic ApplicationContext implementation that holds a single internal
DefaultListableBeanFactory
instance and does not assume a specific bean definition format. |
GenericApplicationListenerAdapter | SmartApplicationListener adapter that determines supported event types
through introspecting the generically declared type of the target listener. |
GenericBeanDefinition | GenericBeanDefinition is a one-stop shop for standard bean definition purposes. |
GenericCallMetaDataProvider | Generic implementation for the CallMetaDataProvider interface. |
GenericCollectionTypeResolver | Helper class for determining element types of collections and maps. |
GenericConversionService | Base ConversionService implementation suitable for use in most environments. |
GenericConverter | Generic converter interface for converting between two or more types. |
GenericConverter.ConvertiblePair | Holder for a source-to-target class pair. |
GenericFilterBean | Simple base implementation of javax.servlet.Filter which treats
its config parameters (init-param entries within the
filter tag in web.xml ) as bean properties. |
GenericMarshaller | Subinterface of Marshaller that has support for Java 5 generics. |
GenericMessageEndpointFactory | Generic implementation of the JCA 1.5 javax.resource.spi.endpoint.MessageEndpointFactory interface, providing transaction management capabilities for any kind of message listener object (e.g. |
GenericMessageEndpointFactory.InternalResourceException | Internal exception thrown when a ResourceExeption has been encountered during the endpoint invocation. |
GenericMessageEndpointManager | Generic bean that manages JCA 1.5 message endpoints within a Spring application context, activating and deactivating the endpoint as part of the application context's lifecycle. |
GenericPortletBean | Simple extension of javax.portlet.GenericPortlet that treats
its config parameters as bean properties. |
GenericPropertiesContextLoader |
Concrete implementation of |
GenericSqlQuery | |
GenericStoredProcedure | Concrete implementation making it possible to define the RDBMS stored procedures in an application context without writing a custom Java implementation class. |
GenericTableMetaDataProvider | A generic implementation of the TableMetaDataProvider that should provide
enough features for all supported databases. |
GenericTypeResolver | Helper class for resolving generic types against type variables. |
GenericUnmarshaller | Subinterface of Unmarshaller that has support for Java 5 generics. |
GenericWebApplicationContext | Subclass of GenericApplicationContext , suitable for web environments. |
GenericXmlApplicationContext | Convenient application context with built-in XML support. |
GenericXmlContextLoader | Concrete implementation of AbstractGenericContextLoader which reads
bean definitions from XML resources. |
GlassFishLoadTimeWeaver | LoadTimeWeaver implementation for GlassFish's InstrumentableClassLoader. |
GlassFishWorkManagerTaskExecutor | Spring TaskExecutor adapter for the GlassFish JCA WorkManager. |
GlobalAdvisorAdapterRegistry | Singleton to publish a shared DefaultAdvisorAdapterRegistry instance. |
GroovyObjectCustomizer | Strategy used by GroovyScriptFactory to allow the customization of
a created GroovyObject. |
GroovyScriptFactory | ScriptFactory implementation
for a Groovy script. |
H2SequenceMaxValueIncrementer | DataFieldMaxValueIncrementer that retrieves the next value of a given H2 Database sequence. |
HandlerAdapter | Portlet MVC framework SPI interface, allowing parameterization of core MVC workflow. |
HandlerAdapter | MVC framework SPI interface, allowing parameterization of core MVC workflow. |
HandlerExceptionResolver | Interface to be implemented by objects than can resolve exceptions thrown during handler mapping or execution, in the typical case to error views. |
HandlerExceptionResolver | Interface to be implemented by objects than can resolve exceptions thrown during handler mapping or execution, in the typical case to error views. |
HandlerExecutionChain | Handler execution chain, consisting of handler object and any handler interceptors. |
HandlerExecutionChain | Handler execution chain, consisting of handler object and any handler interceptors. |
HandlerInterceptor | Workflow interface that allows for customized handler execution chains. |
HandlerInterceptor | Workflow interface that allows for customized handler execution chains. |
HandlerInterceptorAdapter | Abstract adapter class for the HandlerInterceptor interface,
for simplified implementation of pre-only/post-only interceptors. |
HandlerInterceptorAdapter | Abstract adapter class for the HandlerInterceptor interface, for simplified implementation of pre-only/post-only interceptors. |
HandlerMapping | Interface to be implemented by objects that define a mapping between requests and handler objects. |
HandlerMapping | Interface to be implemented by objects that define a mapping between requests and handler objects. |
HandlerMethodInvocationException | Exception indicating that the execution of an annotated MVC handler method failed. |
HandlerMethodInvoker | Support class for invoking an annotated handler method. |
HandlerMethodResolver | Support class for resolving web method annotations in a handler type. |
HessianClientInterceptor | org.aopalliance.intercept.MethodInterceptor for accessing a Hessian service. |
HessianExporter | General stream-based protocol exporter for a Hessian endpoint. |
HessianProxyFactoryBean | FactoryBean for Hessian proxies. |
HessianServiceExporter | Servlet-API-based HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy. |
HeuristicCompletionException | Exception that represents a transaction failure caused by a heuristic decision on the side of the transaction coordinator. |
HibernateAccessor | Base class for HibernateTemplate and HibernateInterceptor ,
defining common properties such as SessionFactory and flushing behavior. |
HibernateCallback<T> | Callback interface for Hibernate code. |
HibernateDaoSupport | Convenient super class for Hibernate-based data access objects. |
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. |
HibernateJdbcException | Hibernate-specific subclass of UncategorizedDataAccessException, for JDBC exceptions that Hibernate wrapped. |
HibernateJpaDialect | JpaDialect implementation for
Hibernate EntityManager. |
HibernateJpaVendorAdapter | JpaVendorAdapter implementation for
Hibernate EntityManager. |
HibernateObjectRetrievalFailureException | Hibernate-specific subclass of ObjectRetrievalFailureException. |
HibernateOperations | Interface that specifies a basic set of Hibernate operations,
implemented by HibernateTemplate . |
HibernateOptimisticLockingFailureException | Hibernate-specific subclass of ObjectOptimisticLockingFailureException. |
HibernateQueryException | Hibernate-specific subclass of InvalidDataAccessResourceUsageException, thrown on invalid HQL query syntax. |
HibernateSystemException | Hibernate-specific subclass of UncategorizedDataAccessException,
for Hibernate system errors that do not match any concrete
org.springframework.dao exceptions. |
HibernateTemplate | Helper class that simplifies Hibernate data access code. |
HibernateTransactionManager | PlatformTransactionManager
implementation for a single Hibernate org.hibernate.SessionFactory. |
HiddenHttpMethodFilter | javax.servlet.Filter that converts posted method parameters into HTTP methods,
retrievable via getMethod() . |
HiddenInputTag | Data-binding aware JSP tag for rendering a hidden HTML 'input ' field
containing the databound value. |
HierarchicalBeanFactory | Sub-interface implemented by bean factories that can be part of a hierarchy. |
HierarchicalMessageSource | Sub-interface of MessageSource to be implemented by objects that can resolve messages hierarchically. |
HierarchicalThemeSource | Sub-interface of ThemeSource to be implemented by objects that can resolve theme messages hierarchically. |
HotSwappableTargetSource | TargetSource implementation that
caches a local target object, but allows the target to be swapped
while the application is running. |
HsqlMaxValueIncrementer | DataFieldMaxValueIncrementer that increments the maximum value of a given HSQL table
with the equivalent of an auto-increment column. |
HsqlSequenceMaxValueIncrementer | DataFieldMaxValueIncrementer that retrieves the next value of a given HSQL sequence. |
HsqlTableMetaDataProvider | The HSQL specific implementation of the TableMetaDataProvider . |
HtmlEscapeTag | Sets default HTML escape value for the current page. |
HtmlEscapingAwareTag | Superclass for tags that output content that might get HTML-escaped. |
HtmlUtils | Utility class for HTML escaping. |
HttpAccessor | Base class for RestTemplate
and other HTTP accessing gateway helpers, defining common properties
such as the ClientHttpRequestFactory to operate on. |
HttpClientErrorException | Exception thrown when an HTTP 4xx is received. |
HttpEntity<T> | Represents an HTTP request or response entity, consisting of headers and body. |
HttpHeaders | Represents HTTP request and response headers, mapping string header names to list of string values. |
HttpInputMessage | Represents an HTTP input message, consisting of headers
and a readable body . |
HttpInvokerClientConfiguration | Configuration interface for executing HTTP invoker requests. |
HttpInvokerClientInterceptor | org.aopalliance.intercept.MethodInterceptor for accessing an HTTP invoker service. |
HttpInvokerProxyFactoryBean | FactoryBean for HTTP invoker proxies. |
HttpInvokerRequestExecutor | Strategy interface for actual execution of an HTTP invoker request. |
HttpInvokerServiceExporter | Servlet-API-based HTTP request handler that exports the specified service bean as HTTP invoker service endpoint, accessible via an HTTP invoker proxy. |
HttpMediaTypeException | Abstract base for exceptions related to media types. |
HttpMediaTypeNotAcceptableException | Exception thrown when the request handler cannot generate a response that is acceptable by the client. |
HttpMediaTypeNotSupportedException | Exception thrown when a client POSTs or PUTs content not supported by request handler. |
HttpMessage | Represents the base interface for HTTP request and response messages. |
HttpMessageConversionException | Thrown by HttpMessageConverter implementations when the conversion fails. |
HttpMessageConverter<T> | Strategy interface that specifies a converter that can convert from and to HTTP requests and responses. |
HttpMessageConverterExtractor<T> | Response extractor that uses the given entity converters to convert the response
into a type T . |
HttpMessageNotReadableException | Thrown by HttpMessageConverter implementations when the
read method fails. |
HttpMessageNotWritableException | Thrown by HttpMessageConverter implementations when the
org.springframework.http.converter.HttpMessageConverter#write(Object, org.springframework.http.HttpOutputMessage) write method fails. |
HttpMethod | Java 5 enumeration of HTTP request methods. |
HttpOutputMessage | Represents an HTTP output message, consisting of headers
and a writable body . |
HttpRequest | Represents an HTTP request message, consisting of method
and uri . |
HttpRequestHandler | Plain handler interface for components that process HTTP requests, analogous to a Servlet. |
HttpRequestHandlerAdapter | Adapter to use the plain HttpRequestHandler
interface with the generic DispatcherServlet . |
HttpRequestHandlerServlet | Simple HttpServlet that delegates to an HttpRequestHandler bean defined
in Spring's root web application context. |
HttpRequestMethodNotSupportedException | Exception thrown when a request handler does not support a specific request method. |
HttpRequestWrapper | Provides a convenient implementation of the HttpRequest interface that can be overridden to adapt the
request. |
HttpServerErrorException | Exception thrown when an HTTP 5xx is received. |
HttpServletBean | Simple extension of javax.servlet.http.HttpServlet which treats
its config parameters (init-param entries within the
servlet tag in web.xml ) as bean properties. |
HttpSessionMutexListener | Servlet 2.3 HttpSessionListener that automatically exposes the session mutex when an HttpSession gets created. |
HttpSessionRequiredException | Exception thrown when an HTTP request handler requires a pre-existing session. |
HttpStatus | Java 5 enumeration of HTTP status codes. |
HttpStatus.Series | Java 5 enumeration of HTTP status series. |
HttpStatusCodeException | Abstract base class for exceptions based on an HttpStatus . |
Identifier | |
IdentityNamingStrategy | An implementation of the ObjectNamingStrategy interface that
creates a name based on the the identity of a given instance. |
IdTransferringMergeEventListener | Extension of Hibernate's DefaultMergeEventListener, transferring the ids
of newly saved objects to the corresponding original objects (that are part
of the detached object graph passed into the merge method). |
IfProfileValue | Test annotation to indicate that a test is enabled for a specific testing profile or environment. |
IllegalStateException | Runtime exception mirroring the JMS IllegalStateException. |
IllegalTransactionStateException | Exception thrown when the existence or non-existence of a transaction amounts to an illegal state according to the transaction propagation behavior that applies. |
Import | Indicates one or more @Configuration classes to import. |
ImportDefinition | Representation of an import that has been processed during the parsing process. |
ImportResource | Indicates one or more resources containing bean definitions to import. |
IncorrectResultSetColumnCountException | Data access exception thrown when a result set did not have the correct column count, for example when expecting a single column but getting 0 or more than 1 columns. |
IncorrectResultSizeDataAccessException | Data access exception thrown when a result was not of the expected size, for example when expecting a single row but getting 0 or more than 1 rows. |
IncorrectUpdateSemanticsDataAccessException | Data access exception thrown when something unintended appears to have happened with an update, but the transaction hasn't already been rolled back. |
Indexer | An Indexer can index into some proceeding structure to access a particular piece of it. |
InfrastructureAdvisorAutoProxyCreator | Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors. |
InfrastructureProxy | Interface to be implemented by transparent resource proxies that need to be considered as equal to the underlying resource, for example for consistent lookup key comparisons. |
InitBinder | Annotation that identifies methods which initialize the
WebDataBinder which
will be used for populating command and form object arguments
of annotated handler methods. |
InitDestroyAnnotationBeanPostProcessor | BeanPostProcessor implementation
that invokes annotated init and destroy methods. |
InitializeDatabaseBeanDefinitionParser | BeanDefinitionParser that parses an initialize-database element and
creates a BeanDefinition of type DataSourceInitializer . |
InitializingBean | Interface to be implemented by beans that need to react once all their properties have been set by a BeanFactory: for example, to perform custom initialization, or merely to check that all mandatory properties have been set. |
InjectionMetadata | Internal class for managing injection metadata. |
InjectionMetadata.InjectedElement | |
InlineList | Represent a list in an expression, e.g. |
InputSourceEditor | Editor for org.xml.sax.InputSource , converting from a
Spring resource location String to a SAX InputSource object. |
InputStreamEditor | One-way PropertyEditor which can convert from a text String to a
java.io.InputStream , interpreting the given String
as Spring resource location (e.g. |
InputStreamResource | Resource implementation for a given InputStream. |
InputStreamSource | Simple interface for objects that are sources for an InputStream. |
InputTag | Data-binding-aware JSP tag for rendering an HTML 'input '
element with a 'type ' of 'text '. |
InstantiationAwareBeanPostProcessor | Subinterface of BeanPostProcessor that adds a before-instantiation callback,
and a callback after instantiation but before explicit properties are set or
autowiring occurs. |
InstantiationAwareBeanPostProcessorAdapter | Adapter that implements all methods on SmartInstantiationAwareBeanPostProcessor
as no-ops, which will not change normal processing of each bean instantiated
by the container. |
InstantiationModelAwarePointcutAdvisor | Interface to be implemented by Spring AOP Advisors wrapping AspectJ aspects that may have a lazy initialization strategy. |
InstantiationStrategy | Interface responsible for creating instances corresponding to a root bean definition. |
InstrumentationLoadTimeWeaver | LoadTimeWeaver relying on VM Instrumentation. |
InstrumentationSavingAgent | Java agent that saves the Instrumentation interface from the JVM for later use. |
InteractionCallback<T> | Generic callback interface for code that operates on a CCI Interaction. |
InterceptingClientHttpRequestFactory | Wrapper for a ClientHttpRequestFactory that has support for ClientHttpRequestInterceptor s. |
InterceptingHttpAccessor | Base class for RestTemplate and other HTTP accessing gateway helpers, adding
interceptor-related properties to HttpAccessor 's common properties. |
InterfaceBasedMBeanInfoAssembler | Subclass of AbstractReflectiveMBeanInfoAssembler that allows for
the management interface of a bean to be defined using arbitrary interfaces. |
InternalParseException | Wraps a real parse exception. |
InternalPathMethodNameResolver | Simple implementation of MethodNameResolver that maps URL to
method name. |
InternalResourceView | Wrapper for a JSP or other resource within the same web application. |
InternalResourceViewResolver | Convenient subclass of UrlBasedViewResolver that supports
InternalResourceView (i.e. |
InternetAddressEditor | Editor for java.mail.internet.InternetAddress ,
to directly populate an InternetAddress property. |
InterruptibleBatchPreparedStatementSetter | Extension of the BatchPreparedStatementSetter interface,
adding a batch exhaustion check. |
IntLiteral | Expression language AST node that represents an integer literal. |
IntroductionAdvisor | Superinterface for advisors that perform one or more AOP introductions. |
IntroductionAwareMethodMatcher | A specialized type of MethodMatcher that takes into account introductions when matching methods. |
IntroductionInfo | Interface supplying the information necessary to describe an introduction. |
IntroductionInfoSupport | Support for implementations of IntroductionInfo . |
IntroductionInterceptor | Subinterface of AOP Alliance MethodInterceptor that allows additional interfaces to be implemented by the interceptor, and available via a proxy using that interceptor. |
IntrospectorCleanupListener | Listener that flushes the JDK's java.beans.Introspector JavaBeans Introspector cache on web app shutdown. |
InvalidClientIDException | Runtime exception mirroring the JMS InvalidClientIDException. |
InvalidDataAccessApiUsageException | Exception thrown on incorrect usage of the API, such as failing to "compile" a query object that needed compilation before execution. |
InvalidDataAccessResourceUsageException | Root for exceptions thrown when we use a data access resource incorrectly. |
InvalidDestinationException | Runtime exception mirroring the JMS InvalidDestinationException. |
InvalidInvocationException | Thrown when trying to invoke an operation on a proxy that is not exposed by the proxied MBean resource's management interface. |
InvalidIsolationLevelException | Exception that gets thrown when an invalid isolation level is specified, i.e. |
InvalidMetadataException | Thrown by the JmxAttributeSource when it encounters
incorrect metadata on a managed resource or one of its methods. |
InvalidPropertyException | Exception thrown when referring to an invalid bean property. |
InvalidResultSetAccessException | Exception thrown when a ResultSet has been accessed in an invalid fashion. |
InvalidResultSetAccessException | Exception thrown when a ResultSet has been accessed in an invalid fashion. |
InvalidSelectorException | Runtime exception mirroring the JMS InvalidSelectorException. |
InvalidTimeoutException | Exception that gets thrown when an invalid timeout is specified, that is, the specified timeout valid is out of range or the transaction manager implementation doesn't support timeouts. |
InvertibleComparator<T> | A decorator for a comparator, with an "ascending" flag denoting whether comparison results should be treated in forward (standard ascending) order or flipped for reverse (descending) order. |
InvocationFailureException | Thrown when an invocation on an MBean resource failed with an exception (either a reflection exception or an exception thrown by the target method itself). |
Isolation | Enumeration that represents transaction isolation levels for use
with the Transactional annotation, corresponding to the
TransactionDefinition interface. |
IsolationLevelDataSourceAdapter | An adapter for a target javax.sql.DataSource, applying the current
Spring transaction's isolation level (and potentially specified user credentials)
to every getConnection call. |
IsolationLevelDataSourceRouter | DataSource that routes to one of various target DataSources based on the current transaction isolation level. |
JamonPerformanceMonitorInterceptor | Performance monitor interceptor that uses JAMon library to perform the performance measurement on the intercepted method and output the stats. |
JasperReportsCsvView | Implementation of AbstractJasperReportsSingleFormatView
that renders report results in CSV format. |
JasperReportsHtmlView | Implementation of AbstractJasperReportsSingleFormatView
that renders report results in HTML format. |
JasperReportsMultiFormatView | Jasper Reports view class that allows for the actual rendering format to be specified at runtime using a parameter contained in the model. |
JasperReportsPdfView | Implementation of AbstractJasperReportsSingleFormatView
that renders report results in PDF format. |
JasperReportsUtils | Utility methods for working with JasperReports. |
JasperReportsViewResolver | ViewResolver implementation that
resolves instances of AbstractJasperReportsView by translating
the supplied view name into the URL of the report file. |
JasperReportsXlsView | Implementation of AbstractJasperReportsSingleFormatView
that renders report results in XLS format. |
JavaMailSender | Extended MailSender interface for JavaMail,
supporting MIME messages both as direct arguments and through preparation
callbacks. |
JavaMailSenderImpl | Production implementation of the JavaMailSender interface,
supporting both JavaMail MimeMessage MimeMessages and Spring
SimpleMailMessages . |
JavaScriptUtils | Utility class for JavaScript escaping. |
Jaxb2Marshaller | Implementation of the Marshaller interface for JAXB 2.0. |
Jaxb2RootElementHttpMessageConverter | Implementation of HttpMessageConverter that can read
and write XML using JAXB2. |
JaxRpcPortClientInterceptor |
This class is deprecated.
in favor of JAX-WS support in org.springframework.remoting.jaxws
|
JaxRpcPortProxyFactoryBean |
This class is deprecated.
in favor of JAX-WS support in org.springframework.remoting.jaxws
|
JaxRpcServicePostProcessor |
This interface is deprecated.
in favor of JAX-WS support in org.springframework.remoting.jaxws
|
JaxRpcSoapFaultException |
This class is deprecated.
in favor of JAX-WS support in org.springframework.remoting.jaxws
|
JaxWsPortClientInterceptor | org.aopalliance.intercept.MethodInterceptor for accessing a specific port of a JAX-WS service. |
JaxWsPortProxyFactoryBean | FactoryBean for a specific port of a
JAX-WS service. |
JaxWsSoapFaultException | Spring SoapFaultException adapter for the JAX-WS javax.xml.ws.soap.SOAPFaultException class. |
JBossLoadTimeWeaver | LoadTimeWeaver implementation for JBoss's instrumentable ClassLoader. |
JBossNativeJdbcExtractor | Implementation of the NativeJdbcExtractor interface for JBoss,
supporting JBoss Application Server 3.2.4+. |
JBossWorkManagerTaskExecutor | Spring TaskExecutor adapter for the JBoss JCA WorkManager. |
JBossWorkManagerUtils | Utility class for obtaining the JBoss JCA WorkManager, typically for use in web applications. |
Jdbc4NativeJdbcExtractor | NativeJdbcExtractor implementation that delegates to JDBC 4.0's
unwrap method, as defined by java.sql.Wrapper. |
Jdbc4SqlXmlHandler | Default implementation of the SqlXmlHandler interface. |
JdbcAccessor | Base class for JdbcTemplate and
other JDBC-accessing DAO helpers, defining common properties such as
DataSource and exception translator. |
JdbcBeanDefinitionReader | Bean definition reader that reads values from a database table, based on a given SQL statement. |
JdbcDaoSupport | Convenient super class for JDBC-based data access objects. |
JdbcNamespaceHandler | NamespaceHandler for JDBC configuration namespace. |
JdbcOperations | Interface specifying a basic set of JDBC operations. |
JdbcTemplate | This is the central class in the JDBC core package. |
JdbcTestUtils | JdbcTestUtils is a collection of JDBC related utility methods for use in unit and integration testing scenarios. |
JdbcTransactionObjectSupport | Convenient base class for JDBC-aware transaction objects. |
JdbcUpdateAffectedIncorrectNumberOfRowsException | Exception thrown when a JDBC update affects an unexpected number of rows. |
JdbcUtils | Generic utility methods for working with JDBC. |
JdkRegexpMethodPointcut | Regular expression pointcut based on the java.util.regex package. |
JdkVersion | Internal helper class used to find the Java/JVM version that Spring is operating on, to allow for automatically adapting to the present platform's capabilities. |
JdoAccessor | Base class for JdoTemplate and JdoInterceptor, defining common properties such as PersistenceManagerFactory and flushing behavior. |
JdoCallback<T> | Callback interface for JDO code. |
JdoDaoSupport | Convenient super class for JDO data access objects. |
JdoDialect | SPI strategy that allows for customizing integration with a specific JDO provider, in particular regarding transaction management and exception translation. |
JdoInterceptor | This interceptor binds a new JDO PersistenceManager to the thread before a method call, closing and removing it afterwards in case of any method outcome. |
JdoObjectRetrievalFailureException | JDO-specific subclass of ObjectRetrievalFailureException. |
JdoOperations | Interface that specifies a basic set of JDO operations,
implemented by JdoTemplate . |
JdoOptimisticLockingFailureException | JDO-specific subclass of ObjectOptimisticLockingFailureException. |
JdoResourceFailureException | JDO-specific subclass of DataAccessResourceFailureException. |
JdoSystemException | JDO-specific subclass of UncategorizedDataAccessException,
for JDO system errors that do not match any concrete
org.springframework.dao exceptions. |
JdoTemplate | Helper class that simplifies JDO data access code, and converts
JDOExceptions into Spring DataAccessExceptions, following the
org.springframework.dao exception hierarchy. |
JdoTransactionManager | PlatformTransactionManager implementation
for a single JDO javax.jdo.PersistenceManagerFactory. |
JdoUsageException | JDO-specific subclass of InvalidDataAccessApiUsageException. |
JeeNamespaceHandler | NamespaceHandler
for the 'jee ' namespace. |
JibxMarshaller | Implementation of the Marshaller and Unmarshaller interfaces for JiBX. |
JmsAccessor | Base class for JmsTemplate and other
JMS-accessing gateway helpers, defining common properties such as the
JMS ConnectionFactory to operate on. |
JmsActivationSpecConfig | Common configuration object for activating a JMS message endpoint. |
JmsActivationSpecFactory | Strategy interface for creating JCA 1.5 ActivationSpec objects
based on a configured JmsActivationSpecConfig object. |
JmsDestinationAccessor | Base class for JmsTemplate and other
JMS-accessing gateway helpers, adding destination-related properties to
JmsAccessor's common properties. |
JmsException | Base class for exception thrown by the framework whenever it encounters a problem related to JMS. |
JmsGatewaySupport | Convenient super class for application classes that need JMS access. |
JmsInvokerClientInterceptor | org.aopalliance.intercept.MethodInterceptor for accessing a JMS-based remote service. |
JmsInvokerProxyFactoryBean | FactoryBean for JMS invoker proxies. |
JmsInvokerServiceExporter | JMS message listener that exports the specified service bean as a JMS service endpoint, accessible via a JMS invoker proxy. |
JmsMessageEndpointFactory | JMS-specific implementation of the JCA 1.5 javax.resource.spi.endpoint.MessageEndpointFactory interface, providing transaction management capabilities for a JMS listener object (e.g. |
JmsMessageEndpointFactory.JmsResourceException | Internal exception thrown when a ResourceExeption has been encountered during the endpoint invocation. |
JmsMessageEndpointManager | Extension of the generic JCA 1.5
GenericMessageEndpointManager ,
adding JMS-specific support for ActivationSpec configuration. |
JmsNamespaceHandler | A NamespaceHandler
for the JMS namespace. |
JmsOperations | Specifies a basic set of JMS operations. |
JmsResourceHolder | JMS resource holder, wrapping a JMS Connection and a JMS Session. |
JmsSecurityException | Runtime exception mirroring the JMS JMSSecurityException. |
JmsTemplate | Helper class that simplifies synchronous JMS access code. |
JmsTemplate102 |
This class is deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based JmsTemplate
|
JmsTransactionManager | PlatformTransactionManager implementation
for a single JMS javax.jms.ConnectionFactory. |
JmsTransactionManager102 |
This class is deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based JmsTransactionManager
|
JmsUtils | Generic utility methods for working with JMS. |
JmxAttributeSource | Interface used by the MetadataMBeanInfoAssembler to
read source-level metadata from a managed resource's class. |
JmxException | General base exception to be thrown on JMX errors. |
JmxMetadataUtils | Utility methods for converting Spring JMX metadata into their plain JMX equivalents. |
JmxUtils | Collection of generic utility methods to support Spring JMX. |
JndiAccessor | Convenient superclass for JNDI accessors, providing "jndiTemplate" and "jndiEnvironment" bean properties. |
JndiCallback<T> | Callback interface to be implemented by classes that need to perform an operation (such as a lookup) in a JNDI context. |
JndiDataSourceLookup | JNDI-based DataSourceLookup implementation. |
JndiDestinationResolver | DestinationResolver implementation which interprets destination names
as JNDI locations (with a configurable fallback strategy). |
JndiLocatorDelegate | JndiLocatorSupport subclass with public lookup methods,
for convenient use as a delegate. |
JndiLocatorSupport | Convenient superclass for classes that can locate any number of JNDI objects. |
JndiLookupFailureException | RuntimeException to be thrown in case of JNDI lookup failures,
in particular from code that does not declare JNDI's checked
javax.naming.NamingException: for example, from Spring's
JndiObjectTargetSource . |
JndiObjectFactoryBean | FactoryBean that looks up a
JNDI object. |
JndiObjectLocator | Convenient superclass for JNDI-based service locators, providing configurable lookup of a specific JNDI resource. |
JndiObjectTargetSource | AOP TargetSource that provides
configurable JNDI lookups for getTarget() calls. |
JndiPropertySource | PropertySource implementation that reads properties from
a JNDI Context. |
JndiRmiClientInterceptor | org.aopalliance.intercept.MethodInterceptor for accessing RMI services from JNDI. |
JndiRmiProxyFactoryBean | FactoryBean for RMI proxies from JNDI. |
JndiRmiServiceExporter | Service exporter which binds RMI services to JNDI. |
JndiTemplate | Helper class that simplifies JNDI operations. |
JndiTemplateEditor | Properties editor for JndiTemplate objects. |
JobDetailAwareTrigger | Interface to be implemented by Quartz Triggers that are aware of the JobDetail object that they are associated with. |
JobDetailBean | Convenience subclass of Quartz's org.quartz.JobDetail class, making bean-style usage easier. |
JobMethodInvocationFailedException | Unchecked exception that wraps an exception thrown from a target method. |
JodaDateTimeFormatAnnotationFormatterFactory | Formats fields annotated with the DateTimeFormat annotation. |
JodaTimeContext | A context that holds user-specific Joda Time settings such as the user's Chronology (calendar system) and time zone. |
JodaTimeContextHolder | A holder for a thread-local user JodaTimeContext . |
JodaTimeFormatterRegistrar | Configures Joda Time's Formatting system for use with Spring. |
JpaAccessor | Base class for JpaTemplate and JpaInterceptor, defining common properties such as EntityManagerFactory and flushing behavior. |
JpaCallback<T> | Callback interface for JPA code. |
JpaDaoSupport | Convenient super class for JPA data access objects. |
JpaDialect | SPI strategy that encapsulates certain functionality that standard JPA 1.0 does not offer, such as access to the underlying JDBC Connection. |
JpaInterceptor | This interceptor binds a new JPA EntityManager to the thread before a method call, closing and removing it afterwards in case of any method outcome. |
JpaObjectRetrievalFailureException | JPA-specific subclass of ObjectRetrievalFailureException. |
JpaOperations | Interface that specifies a basic set of JPA operations,
implemented by JpaTemplate . |
JpaOptimisticLockingFailureException | JPA-specific subclass of ObjectOptimisticLockingFailureException. |
JpaSystemException | JPA-specific subclass of UncategorizedDataAccessException,
for JPA system errors that do not match any concrete
org.springframework.dao exceptions. |
JpaTemplate | Helper class that allows for writing JPA data access code in the same style as with Spring's well-known JdoTemplate and HibernateTemplate classes. |
JpaTransactionManager | PlatformTransactionManager implementation
for a single JPA javax.persistence.EntityManagerFactory. |
JpaVendorAdapter | SPI interface that allows to plug in vendor-specific behavior into Spring's EntityManagerFactory creators. |
JRubyScriptFactory | ScriptFactory implementation
for a JRuby script. |
JRubyScriptUtils | Utility methods for handling JRuby-scripted objects. |
JRubyScriptUtils.JRubyExecutionException | Exception thrown in response to a JRuby RaiseException being thrown from a JRuby method invocation. |
JspAwareRequestContext | JSP-aware (and JSTL-aware) subclass of RequestContext, allowing for
population of the context from a javax.servlet.jsp.PageContext . |
Jsr330ScopeMetadataResolver | Simple ScopeMetadataResolver implementation that follows JSR-330 scoping rules:
defaulting to prototype scope unless javax.inject.Singleton is present. |
JstlUtils | Helper class for preparing JSTL views, in particular for exposing a JSTL localization context. |
JstlView | Specialization of InternalResourceView for JSTL pages,
i.e. |
JtaAfterCompletionSynchronization | Adapter for a JTA Synchronization, invoking the afterCommit /
afterCompletion callbacks of Spring TransactionSynchronization
objects callbacks after the outer JTA transaction has completed. |
JtaLobCreatorSynchronization | Callback for resource cleanup at the end of a JTA transaction. |
JtaTransactionManager | PlatformTransactionManager implementation
for JTA, delegating to a backend JTA provider. |
JtaTransactionObject | JTA transaction object, representing a javax.transaction.UserTransaction. |
KeyGenerator<K> | Cache 'key' extractor. |
KeyHolder | Interface for retrieving keys, typically used for auto-generated keys as potentially returned by JDBC insert statements. |
KeyNamingStrategy | ObjectNamingStrategy implementation that builds
ObjectName instances from the key used in the
"beans" map passed to MBeanExporter . |
LabeledEnum | This interface is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
LabeledEnumResolver | This interface is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
LabelTag | Databinding-aware JSP tag for rendering an HTML 'label ' element
that defines text that is associated with a single form element. |
LangNamespaceHandler | NamespaceHandler that supports the wiring of
objects backed by dynamic languages such as Groovy, JRuby and
BeanShell. |
LangNamespaceUtils | |
LastModified | Supports last-modified HTTP requests to facilitate content caching. |
Lazy | Indicates whether a bean is to be lazily initialized. |
LazyConnectionDataSourceProxy | Proxy for a target DataSource, fetching actual JDBC Connections lazily, i.e. |
LazyInitTargetSource | TargetSource that lazily accesses a
singleton bean from a BeanFactory . |
LazyInitTargetSourceCreator | TargetSourceCreator that enforces a LazyInitTargetSource for each bean that is defined as "lazy-init". |
LazySingletonAspectInstanceFactoryDecorator | Decorator to cause a MetadataAwareAspectInstanceFactory to instantiate only once. |
LetterCodedLabeledEnum | This class is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
Lifecycle | Interface defining methods for start/stop lifecycle control. |
LifecycleProcessor | Strategy interface for processing Lifecycle beans within the ApplicationContext. |
LinkedCaseInsensitiveMap<V> | LinkedHashMap variant that stores String keys in a case-insensitive manner, for example for key-based access in a results table. |
LinkedMultiValueMap<K, V> | Simple implementation of MultiValueMap that wraps a LinkedHashMap,
storing multiple values in a LinkedList. |
ListableBeanFactory | Extension of the BeanFactory interface to be implemented by bean factories
that can enumerate all their bean instances, rather than attempting bean lookup
by name one by one as requested by clients. |
ListenerExecutionFailedException | Exception to be thrown when the execution of a listener method failed. |
ListFactoryBean | Simple factory for shared List instances. |
Literal | Common superclass for nodes representing literals (boolean, string, number, etc). |
LiteralExpression | A very simple hardcoded implementation of the Expression interface that represents a string literal. |
LoadTimeWeaver | Defines the contract for adding one or more ClassFileTransformer ClassFileTransformers to a ClassLoader. |
LoadTimeWeaverAware | Interface to be implemented by any object that wishes to be notified
of the application context's default LoadTimeWeaver . |
LoadTimeWeaverAwareProcessor | BeanPostProcessor
implementation that passes the context's default LoadTimeWeaver
to beans that implement the LoadTimeWeaverAware interface. |
LobCreator | Interface that abstracts potentially database-specific creation of large binary fields and large text fields. |
LobCreatorUtils | Helper class for registering a transaction synchronization for closing a LobCreator, preferring Spring transaction synchronization and falling back to plain JTA transaction synchronization. |
LobHandler | Abstraction for handling large binary fields and large text fields in specific databases, no matter if represented as simple types or Large OBjects. |
LobRetrievalFailureException | Exception to be thrown when a LOB could not be retrieved. |
LocalCacheProviderProxy | Proxy for a Hibernate CacheProvider, delegating to a Spring-managed CacheProvider instance, determined by LocalSessionFactoryBean's "cacheProvider" property. |
LocalConnectionFactoryBean | FactoryBean that creates
a local JCA connection factory in "non-managed" mode (as defined by the
Java Connector Architecture specification). |
LocalContainerEntityManagerFactoryBean | FactoryBean that creates a JPA
javax.persistence.EntityManagerFactory according to JPA's standard
container bootstrap contract. |
LocalDataSourceConnectionProvider | Hibernate connection provider for local DataSource instances in an application context. |
LocalDataSourceJobStore | Subclass of Quartz's JobStoreCMT class that delegates to a Spring-managed DataSource instead of using a Quartz-managed connection pool. |
LocaleChangeInterceptor | Interceptor that allows for changing the current locale on every request, via a configurable request parameter. |
LocaleContext | Strategy interface for determining the current Locale. |
LocaleContextHolder | Simple holder class that associates a LocaleContext instance with the current thread. |
LocaleContextMessageInterpolator | Delegates to a target MessageInterpolator implementation but enforces Spring's managed Locale. |
LocaleEditor | Editor for java.util.Locale , to directly populate a Locale property. |
LocalEntityManagerFactoryBean | FactoryBean that creates a JPA
javax.persistence.EntityManagerFactory according to JPA's standard
standalone bootstrap contract. |
LocaleResolver | Interface for web-based locale resolution strategies that allows for both locale resolution via the request and locale modification via request and response. |
LocalizedResourceHelper | Helper class for loading a localized resource, specified through name, extension and current locale. |
LocalJaxRpcServiceFactory |
This class is deprecated.
in favor of JAX-WS support in org.springframework.remoting.jaxws
|
LocalJaxRpcServiceFactoryBean |
This class is deprecated.
in favor of JAX-WS support in org.springframework.remoting.jaxws
|
LocalJaxWsServiceFactory | Factory for locally defined JAX-WS javax.xml.ws.Service references. |
LocalJaxWsServiceFactoryBean | FactoryBean for locally
defined JAX-WS Service references. |
LocalJtaDataSourceConnectionProvider | Subclass of LocalDataSourceConnectionProvider that will be used if LocalSessionFactoryBean's "dataSource" property is set in combination with a Hibernate TransactionManagerLookup. |
LocalPersistenceManagerFactoryBean | FactoryBean that creates a
JDO javax.jdo.PersistenceManagerFactory. |
LocalRegionFactoryProxy | Proxy for a Hibernate RegionFactory, delegating to a Spring-managed RegionFactory instance, determined by LocalSessionFactoryBean's "cacheRegionFactory" property. |
LocalSessionFactoryBean | FactoryBean that creates a
Hibernate org.hibernate.SessionFactory. |
LocalSlsbInvokerInterceptor | Invoker for a local Stateless Session Bean. |
LocalStatelessSessionProxyFactoryBean | Convenient FactoryBean for local Stateless Session Bean (SLSB) proxies. |
LocalTaskExecutorThreadPool | Quartz ThreadPool adapter that delegates to a Spring-managed TaskExecutor instance, specified on SchedulerFactoryBean. |
LocalTransactionManagerLookup | Implementation of Hibernate's TransactionManagerLookup interface that returns a Spring-managed JTA TransactionManager, determined by LocalSessionFactoryBean's "jtaTransactionManager" property. |
LocalValidatorFactoryBean | This is the central class for javax.validation (JSR-303) setup
in a Spring application context: It bootstraps a javax.validation.ValidationFactory
and exposes it through the Spring Validator interface
as well as through the JSR-303 javax.validation.Validator interface and the
javax.validation.ValidatorFactory interface itself. |
LocalVariableTableParameterNameDiscoverer | Implementation of ParameterNameDiscoverer that uses the LocalVariableTable
information in the method attributes to discover parameter names. |
Location | Class that models an arbitrary location in a resource . |
Log4jConfigListener | Bootstrap listener for custom log4j initialization in a web environment. |
Log4jConfigurer | Convenience class that features simple methods for custom log4j configuration. |
Log4jNestedDiagnosticContextFilter | Request logging filter that adds the request log message to the Log4J nested diagnostic context (NDC) before the request is processed, removing it again after the request is processed. |
Log4jNestedDiagnosticContextInterceptor | Request logging interceptor that adds a request context message to the Log4J nested diagnostic context (NDC) before the request is processed, removing it again after the request is processed. |
Log4jWebConfigurer | Convenience class that performs custom log4j initialization for web environments, allowing for log file paths within the web application, with the option to perform automatic refresh checks (for runtime changes in logging configuration). |
LongLiteral | Expression language AST node that represents a long integer literal. |
LookupDispatchActionSupport | This class is deprecated. as of Spring 3.0 |
LookupOverride | Represents an override of a method that looks up an object in the same IoC context. |
MailAuthenticationException | Exception thrown on failed authentication. |
MailException | Base class for all mail exceptions. |
MailMessage | This is a common interface for mail messages, allowing a user to set key values required in assembling a mail message, without needing to know if the underlying message is a simple text message or a more sophisticated MIME message. |
MailParseException | Exception thrown if illegal message properties are encountered. |
MailPreparationException | Exception to be thrown by user code if a mail cannot be prepared properly, for example when a Velocity template cannot be rendered for the mail text. |
MailSender | This interface defines a strategy for sending simple mails. |
MailSendException | Exception thrown when a mail sending error is encountered. |
ManagedArray | Tag collection class used to hold managed array elements, which may include runtime bean references (to be resolved into bean objects). |
ManagedAttribute | JDK 1.5+ method-level annotation that indicates to expose a given bean property as JMX attribute, corresponding to the ManagedAttribute attribute. |
ManagedAttribute | Metadata that indicates to expose a given bean property as JMX attribute. |
ManagedList<E> | Tag collection class used to hold managed List elements, which may include runtime bean references (to be resolved into bean objects). |
ManagedMap<K, V> | Tag collection class used to hold managed Map values, which may include runtime bean references (to be resolved into bean objects). |
ManagedMetric | JDK 1.5+ method-level annotation that indicates to expose a given bean property as JMX attribute, with added Descriptor properties to indicate that it is a metric. |
ManagedMetric | Metadata that indicates to expose a given bean property as a JMX attribute, with additional descriptor properties that indicate that the attribute is a metric. |
ManagedNotification | JDK 1.5+ method-level annotation that indicates a JMX notification emitted by a bean. |
ManagedNotification | Metadata that indicates a JMX notification emitted by a bean. |
ManagedNotifications | JDK 1.5+ method-level annotation that indicates JMX notifications emitted by
a bean, containing multiple ManagedNotifications |
ManagedOperation | JDK 1.5+ method-level annotation that indicates to expose a given method as JMX operation, corresponding to the ManagedOperation attribute. |
ManagedOperation | Metadata that indicates to expose a given method as JMX operation. |
ManagedOperationParameter | JDK 1.5+ method-level annotation used to provide metadata about operation
parameters, corresponding to a ManagedOperationParameter attribute. |
ManagedOperationParameter | Metadata about JMX operation parameters. |
ManagedOperationParameters | JDK 1.5+ method-level annotation used to provide metadata about
operation parameters, corresponding to an array of
ManagedOperationParameter attributes. |
ManagedProperties | Tag class which represents a Spring-managed Properties instance that supports merging of parent/child definitions. |
ManagedResource | JDK 1.5+ class-level annotation that indicates to register instances of a class with a JMX server, corresponding to the ManagedResource attribute. |
ManagedResource | Metadata indicating that instances of an annotated class are to be registered with a JMX server. |
ManagedSet<E> | Tag collection class used to hold managed Set values, which may include runtime bean references (to be resolved into bean objects). |
ManagedTransactionAdapter | Adapter for a managed JTA Transaction handle, taking a JTA javax.transaction.TransactionManager reference and creating a JTA javax.transaction.Transaction handle for it. |
MapAccessor | EL property accessor that knows how to traverse the keys of a standard java.util.Map. |
MapBindingResult | Map-based implementation of the BindingResult interface, supporting registration and evaluation of binding errors on Map attributes. |
MapCacheManager | Simple cache manager working against a given collection of caches. |
MapDataSourceLookup | Simple DataSourceLookup implementation that relies on a map for doing lookups. |
MapFactoryBean | Simple factory for shared Map instances. |
MappedInterceptor | Holds information about a HandlerInterceptor mapped to a path into the application. |
Mapping | Meta annotation that indicates a web mapping annotation. |
MappingCommAreaOperation | EIS operation object for access to COMMAREA records. |
MappingDispatchActionSupport | This class is deprecated. as of Spring 3.0 |
MappingJacksonHttpMessageConverter | Implementation of HttpMessageConverter
that can read and write JSON using Jackson's ObjectMapper. |
MappingJacksonJsonView | Spring-MVC View that renders JSON content by serializing the model for the current request using Jackson's ObjectMapper. |
MappingRecordOperation | EIS operation object that expects mapped input and output objects, converting to and from CCI Records. |
MappingRecordOperation.RecordCreatorImpl | Implementation of RecordCreator that calls the enclosing
class's createInputRecord method. |
MappingRecordOperation.RecordExtractorImpl | Implementation of RecordExtractor that calls the enclosing
class's extractOutputData method. |
MappingSqlQuery<T> | Reusable query in which concrete subclasses must implement the abstract mapRow(ResultSet, int) method to convert each row of the JDBC ResultSet into an object. |
MappingSqlQueryWithParameters<T> | Reusable RDBMS query in which concrete subclasses must implement the abstract mapRow(ResultSet, int) method to map each row of the JDBC ResultSet into an object. |
MappingSqlQueryWithParameters.RowMapperImpl | Implementation of RowMapper that calls the enclosing
class's mapRow method for each row. |
MapPropertySource | PropertySource that reads keys and values from a Map object. |
MapSqlParameterSource | SqlParameterSource implementation that holds a given Map of parameters. |
Marshaller | Defines the contract for Object XML Mapping Marshallers. |
MarshallingException | Base class for exception thrown when a marshalling or unmarshalling error occurs. |
MarshallingFailureException | Exception thrown on marshalling failure. |
MarshallingHttpMessageConverter | Implementation of HttpMessageConverter
that can read and write XML using Spring's Marshaller and Unmarshaller abstractions. |
MarshallingMessageConverter | Spring JMS MessageConverter that uses a Marshaller and Unmarshaller . |
MarshallingSource | Source implementation that uses a Marshaller .Can be constructed with a
Marshaller and an object to be marshalled. |
MarshallingView | Spring-MVC View that allows for response context to be rendered as the result of marshalling by a Marshaller . |
MatchAlwaysTransactionAttributeSource | Very simple implementation of TransactionAttributeSource which will always return the same TransactionAttribute for all methods fed to it. |
MaxUploadSizeExceededException | MultipartException subclass thrown when an upload exceeds the maximum upload size allowed. |
MBeanClientInterceptor | org.aopalliance.intercept.MethodInterceptor that routes calls to an
MBean running on the supplied MBeanServerConnection . |
MBeanConnectFailureException | Thrown when an invocation failed because of an I/O problem on the MBeanServerConnection. |
MBeanExporter | JMX exporter that allows for exposing any Spring-managed bean to a JMX javax.management.MBeanServer, without the need to define any JMX-specific information in the bean classes. |
MBeanExporterListener | A listener that allows application code to be notified when an MBean is
registered and unregistered via an MBeanExporter . |
MBeanExportException | Exception thrown in case of failure when exporting an MBean. |
MBeanExportOperations | Interface that defines the set of MBean export operations that are intended to be accessed by application developers during application runtime. |
MBeanInfoAssembler | Interface to be implemented by all classes that can create management interface metadata for a managed resource. |
MBeanInfoRetrievalException | Thrown if an exception is encountered when trying to retrieve MBean metadata. |
MBeanProxyFactoryBean | Creates a proxy to a managed resource running either locally or remotely. |
MBeanRegistrationSupport | Provides supporting infrastructure for registering MBeans with an javax.management.MBeanServer. |
MBeanServerConnectionFactoryBean | FactoryBean that creates a JMX 1.2 MBeanServerConnection
to a remote MBeanServer exposed via a JMXServerConnector . |
MBeanServerFactoryBean | FactoryBean that obtains an javax.management.MBeanServer reference
through the standard JMX 1.2 javax.management.MBeanServerFactory
API (which is available on JDK 1.5 or as part of a JMX 1.2 provider). |
MBeanServerNotFoundException | Exception thrown when we cannot locate an instance of an MBeanServer ,
or when more than one instance is found. |
MediaType | Represents an Internet Media Type, as defined in the HTTP specification. |
MediaTypeEditor | java.beans.PropertyEditor Editor for MediaType
descriptors, to automatically convert String specifications
(e.g. |
Mergeable | Interface representing an object whose value set can be merged with that of a parent object. |
MergedBeanDefinitionPostProcessor | Post-processor callback interface for merged bean definitions at runtime. |
MessageCodesResolver | Strategy interface for building message codes from validation error codes. |
MessageConversionException | Thrown by MessageConverter implementations when the conversion
of an object to/from a javax.jms.Message fails. |
MessageConverter | Strategy interface that specifies a converter between Java objects and JMS messages. |
MessageCreator | Creates a JMS message given a Session. |
MessageEOFException | Runtime exception mirroring the JMS MessageEOFException. |
MessageFormatException | Runtime exception mirroring the JMS MessageFormatException. |
MessageListenerAdapter | Message listener adapter that delegates the handling of messages to target listener methods via reflection, with flexible message type conversion. |
MessageListenerAdapter102 |
This class is deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based MessageListenerAdapter
|
MessageNotReadableException | Runtime exception mirroring the JMS MessageNotReadableException. |
MessageNotWriteableException | Runtime exception mirroring the JMS MessageNotWriteableException. |
MessagePostProcessor | To be used with JmsTemplate's send method that convert an object to a message. |
MessageSource | Strategy interface for resolving messages, with support for the parameterization and internationalization of such messages. |
MessageSourceAccessor | Helper class for easy access to messages from a MessageSource, providing various overloaded getMessage methods. |
MessageSourceAware | Interface to be implemented by any object that wishes to be notified of the MessageSource (typically the ApplicationContext) that it runs in. |
MessageSourceResolvable | Interface for objects that are suitable for message resolution in a
MessageSource . |
MessageSourceResourceBundle | Helper class that allows for accessing a Spring
MessageSource as a java.util.ResourceBundle. |
MessageSourceResourceBundleLocator | Implementation of Hibernate Validator 4.1's ResourceBundleLocator interface,
exposing a Spring MessageSource as localized MessageSourceResourceBundle . |
MessageSourceSupport | Base class for message source implementations, providing support infrastructure
such as java.text.MessageFormat handling but not implementing concrete
methods defined in the MessageSource . |
MessageTag | Custom JSP tag to look up a message in the scope of this page. |
MessageType | Constants that indicate a target message type to convert to: a javax.jms.TextMessage, a javax.jms.BytesMessage, a javax.jms.MapMessage or an ObjectMessage. |
MetaDataAccessException | Exception indicating that something went wrong during JDBC metadata lookup. |
MetadataAwareAspectInstanceFactory | Subinterface of AspectInstanceFactory
that returns AspectMetadata associated with AspectJ-annotated classes. |
MetadataMBeanInfoAssembler | Implementation of the MBeanInfoAssembler
interface that reads the management interface information from source level metadata. |
MetadataNamingStrategy | An implementation of the ObjectNamingStrategy interface
that reads the ObjectName from the source-level metadata. |
MetadataReader | Simple facade for accessing class metadata, as read by an ASM org.springframework.asm.ClassReader. |
MetadataReaderFactory | Factory interface for MetadataReader instances. |
MethodBeforeAdvice | Advice invoked before a method is invoked. |
MethodBeforeAdviceInterceptor | Interceptor to wrap am MethodBeforeAdvice . |
MethodExclusionMBeanInfoAssembler | AbstractReflectiveMBeanInfoAssembler subclass that allows
method names to be explicitly excluded as MBean operations and attributes. |
MethodExecutor | MethodExecutors are built by the resolvers and can be cached by the infrastructure to repeat an operation quickly without going back to the resolvers. |
MethodFilter | MethodFilter instances allow SpEL users to fine tune the behaviour of the method resolution process. |
MethodInvocationException | Thrown when a bean property getter or setter method throws an exception, analogous to an InvocationTargetException. |
MethodInvocationProceedingJoinPoint | Implementation of AspectJ ProceedingJoinPoint interface wrapping an AOP Alliance MethodInvocation. |
MethodInvoker | Helper class that allows for specifying a method to invoke in a declarative fashion, be it static or non-static. |
MethodInvokingFactoryBean | FactoryBean which returns a value which is the result of a static or instance
method invocation. |
MethodInvokingJobDetailFactoryBean | FactoryBean that exposes a
org.quartz.JobDetail object which delegates job execution to a
specified (static or non-static) method. |
MethodInvokingJobDetailFactoryBean.MethodInvokingJob | Quartz Job implementation that invokes a specified method. |
MethodInvokingJobDetailFactoryBean.StatefulMethodInvokingJob | Extension of the MethodInvokingJob, implementing the StatefulJob interface. |
MethodInvokingRunnable | Adapter that implements the Runnable interface as a configurable method invocation based on Spring's MethodInvoker. |
MethodInvokingTimerTaskFactoryBean |
This class is deprecated.
as of Spring 3.0, in favor of the scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService
|
MethodLocatingFactoryBean | FactoryBean implementation that locates a Method on a specified bean. |
MethodMapTransactionAttributeSource | Simple TransactionAttributeSource implementation that
allows attributes to be stored per method in a Map. |
MethodMatcher | Part of a Pointcut : Checks whether the target method is eligible for advice. |
MethodMatchers | Static utility methods for composing
MethodMatchers . |
MethodMetadata | Interface that defines abstract access to the annotations of a specific class, in a form that does not require that class to be loaded yet. |
MethodNameBasedMBeanInfoAssembler | Subclass of AbstractReflectiveMBeanInfoAssembler that allows
to specify method names to be exposed as MBean operations and attributes. |
MethodNameResolver | Interface that parameterizes the MultiActionController class using the Strategy GoF Design pattern, allowing the mapping from incoming request to handler method name to be varied without affecting other application code. |
MethodOverride | Object representing the override of a method on a managed object by the IoC container. |
MethodOverrides | Set of method overrides, determining which, if any, methods on a managed object the Spring IoC container will override at runtime. |
MethodParameter | Helper class that encapsulates the specification of a method parameter, i.e. |
MethodReference | |
MethodReplacer | Interface to be implemented by classes that can reimplement any method on an IoC-managed object: the Method Injection form of Dependency Injection. |
MethodResolver | A method resolver attempts locate a method and returns a command executor that can be used to invoke that method. |
MetricType | Represents how the measurement values of a ManagedMetric will change over time |
MillisecondInstantPrinter | Prints Long instances using a DateTimeFormatter. |
MimeContainer | Represents a container for MIME attachments Concrete implementations might adapt a SOAPMessage or an email message. |
MimeMailMessage | Implementation of the MailMessage interface for a JavaMail MIME message, to let message population code interact with a simple message or a MIME message through a common interface. |
MimeMarshaller | Subinterface of Marshaller that can use MIME attachments to optimize
storage of binary data. |
MimeMessageHelper | Helper class for populating a javax.mail.internet.MimeMessage. |
MimeMessagePreparator | Callback interface for the preparation of JavaMail MIME messages. |
MimeUnmarshaller | Subinterface of Unmarshaller that can use MIME attachments
to optimize storage of binary data. |
MissingPortletRequestParameterException | PortletRequestBindingException subclass that indicates a missing parameter. |
MissingServletRequestParameterException | ServletRequestBindingException subclass that indicates a missing parameter. |
MockActionRequest | Mock implementation of the javax.portlet.ActionRequest interface. |
MockActionResponse | Mock implementation of the javax.portlet.ActionResponse interface. |
MockBaseURL | Mock implementation of the javax.portlet.BaseURL interface. |
MockBodyContent | Mock implementation of the javax.servlet.jsp.tagext.BodyContent class. |
MockCacheControl | Mock implementation of the javax.portlet.CacheControl interface. |
MockClientDataRequest | Mock implementation of the javax.portlet.ClientDataRequest interface. |
MockEvent | Mock implementation of the javax.portlet.Event interface. |
MockEventRequest | Mock implementation of the javax.portlet.EventRequest interface. |
MockEventResponse | Mock implementation of the javax.portlet.EventResponse interface. |
MockExpressionEvaluator | Mock implementation of the JSP 2.0 javax.servlet.jsp.el.ExpressionEvaluator interface, delegating to the Jakarta JSTL ExpressionEvaluatorManager. |
MockFilterChain | Mock implementation of the javax.servlet.FilterConfig interface. |
MockFilterConfig | Mock implementation of the javax.servlet.FilterConfig interface. |
MockHttpServletRequest | Mock implementation of the javax.servlet.http.HttpServletRequest interface. |
MockHttpServletResponse | Mock implementation of the javax.servlet.http.HttpServletResponse interface. |
MockHttpSession | Mock implementation of the javax.servlet.http.HttpSession interface. |
MockJspWriter | Mock implementation of the javax.servlet.jsp.JspWriter class. |
MockMimeResponse | Mock implementation of the javax.portlet.MimeResponse interface. |
MockMultipartActionRequest | Mock implementation of the
MultipartActionRequest interface. |
MockMultipartFile | Mock implementation of the MultipartFile
interface. |
MockMultipartHttpServletRequest | Mock implementation of the
MultipartHttpServletRequest interface. |
MockPageContext | Mock implementation of the javax.servlet.jsp.PageContext interface. |
MockPortalContext | Mock implementation of the javax.portlet.PortalContext interface. |
MockPortletConfig | Mock implementation of the javax.portlet.PortletConfig interface. |
MockPortletContext | Mock implementation of the javax.portlet.PortletContext interface. |
MockPortletPreferences | Mock implementation of the javax.portlet.PortletPreferences interface. |
MockPortletRequest | Mock implementation of the javax.portlet.PortletRequest interface. |
MockPortletRequestDispatcher | Mock implementation of the javax.portlet.PortletRequestDispatcher interface. |
MockPortletResponse | Mock implementation of the javax.portlet.PortletResponse interface. |
MockPortletSession | Mock implementation of the javax.portlet.PortletSession interface. |
MockPortletURL | Mock implementation of the javax.portlet.PortletURL interface. |
MockPropertySource | Simple PropertySource implementation for use in testing. |
MockRenderRequest | Mock implementation of the javax.portlet.RenderRequest interface. |
MockRenderResponse | Mock implementation of the javax.portlet.RenderResponse interface. |
MockRequestDispatcher | Mock implementation of the javax.servlet.RequestDispatcher interface. |
MockResourceRequest | Mock implementation of the javax.portlet.ResourceRequest interface. |
MockResourceResponse | Mock implementation of the javax.portlet.ResourceResponse interface. |
MockResourceURL | Mock implementation of the javax.portlet.ResourceURL interface. |
MockServletConfig | Mock implementation of the javax.servlet.ServletConfig interface. |
MockServletContext | Mock implementation of the javax.servlet.ServletContext interface. |
MockStateAwareResponse | Mock implementation of the javax.portlet.StateAwareResponse interface. |
MockStaticEntityMethods | Annotation to indicate a test class for whose @Test methods static methods on Entity classes should be mocked. |
Model | Java-5-specific interface that defines a holder for model attributes. |
ModelAndView | Holder for both Model and View in the web MVC framework. |
ModelAndView | Holder for both Model and View in the web MVC framework. |
ModelAndViewAssert | A collection of assertions intended to simplify testing scenarios dealing
with Spring Web MVC ModelAndView objects. |
ModelAndViewDefiningException | Exception to be thrown on error conditions that should forward to a specific view with a specific model. |
ModelAndViewDefiningException | Exception to be thrown on error conditions that should forward to a specific view with a specific model. |
ModelAndViewResolver | SPI for resolving custom return values from a specific handler method. |
ModelAttribute | Annotation that binds a method parameter or method return value to a named model attribute, exposed to a web view. |
ModelMap | Implementation of java.util.Map for use when building model data for use with UI tools. |
ModelMBeanNotificationPublisher | NotificationPublisher implementation that uses the infrastructure
provided by the ModelMBean interface to track
javax.management.NotificationListener javax.management.NotificationListeners
and send Notification Notifications to those listeners. |
MultiActionController | Controller
implementation that allows multiple request types to be handled by the same
class. |
MultipartActionRequest | Interface which provides additional methods for dealing with multipart content within a portlet request, allowing to access uploaded files. |
MultipartException | Exception thrown when multipart resolution fails. |
MultipartFile | A representation of an uploaded file received in a multipart request. |
MultipartFilter | Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver. |
MultipartHttpServletRequest | Provides additional methods for dealing with multipart content within a servlet request, allowing to access uploaded files. |
MultipartRequest | This interface defines the multipart request access operations that are exposed for actual multipart requests. |
MultipartResolver | A strategy interface for multipart file upload resolution in accordance with RFC 1867. |
MultiValueMap<K, V> | Extension of the Map interface that stores multiple values. |
MutablePersistenceUnitInfo | Spring's base implementation of the JPA javax.persistence.spi.PersistenceUnitInfo interface, used to bootstrap an EntityManagerFactory in a container. |
MutablePropertySources | Default implementation of the PropertySources interface. |
MutablePropertyValues | Default implementation of the PropertyValues interface. |
MutableSortDefinition | Mutable implementation of the SortDefinition interface. |
MvcAnnotationDriven | Specifies the Spring MVC "annotation-driven" container feature. |
MvcDefaultServletHandler | Specifies the Spring MVC "default-servlet-handler" container feature. |
MvcNamespaceHandler | NamespaceHandler for Spring MVC configuration namespace. |
MvcResources | Specifies the Spring MVC "resources" container feature. |
MvcViewControllers | Specifies the Spring MVC "View Controllers" container feature. |
MySQLMaxValueIncrementer | DataFieldMaxValueIncrementer that increments the maximum value of a given MySQL table
with the equivalent of an auto-increment column. |
NamedBean | Counterpart of BeanNameAware. |
NamedInheritableThreadLocal<T> | InheritableThreadLocal subclass that exposes a specified name
as toString() result (allowing for introspection). |
NamedParameterBatchUpdateUtils | Generic utility methods for working with JDBC batch statements using named parameters. |
NamedParameterJdbcDaoSupport | Extension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well. |
NamedParameterJdbcOperations | Interface specifying a basic set of JDBC operations allowing the use of named parameters rather than the traditional '?' placeholders. |
NamedParameterJdbcTemplate | Template class with a basic set of JDBC operations, allowing the use of named parameters rather than traditional '?' placeholders. |
NamedParameterUtils | Helper methods for named parameter parsing. |
NamedThreadLocal<T> | ThreadLocal subclass that exposes a specified name
as toString() result (allowing for introspection). |
NameMatchMethodPointcut | Pointcut bean for simple method name matches, as alternative to regexp patterns. |
NameMatchMethodPointcutAdvisor | Convenient class for name-match method pointcuts that hold an Advice, making them an Advisor. |
NameMatchTransactionAttributeSource | Simple TransactionAttributeSource implementation that
allows attributes to be matched by registered name. |
NamespaceHandler | Base interface used by the DefaultBeanDefinitionDocumentReader
for handling custom namespaces in a Spring XML configuration file. |
NamespaceHandlerResolver | Used by the DefaultBeanDefinitionDocumentReader to
locate a NamespaceHandler implementation for a particular namespace URI. |
NamespaceHandlerSupport | Support class for implementing custom NamespaceHandlers . |
NativeJdbcExtractor | Interface for extracting native JDBC objects from wrapped objects coming from connection pools. |
NativeJdbcExtractorAdapter | Abstract adapter class for the NativeJdbcExtractor interface,
for simplified implementation of basic extractors. |
NativeWebRequest | Extension of the WebRequest interface, exposing the
native request and response objects in a generic fashion. |
NestedCheckedException | Handy class for wrapping checked Exceptions with a root cause. |
NestedExceptionUtils | Helper class for implementing exception classes which are capable of holding nested exceptions. |
NestedIOException | Subclass of IOException that properly handles a root cause, exposing the root cause just like NestedChecked/RuntimeException does. |
NestedPathTag | Nested-path tag, to support and assist with nested beans or bean properties in the model. |
NestedRuntimeException | Handy class for wrapping runtime Exceptions with a root cause. |
NestedServletException | Subclass of ServletException that properly handles a root cause in terms of message and stacktrace, just like NestedChecked/RuntimeException does. |
NestedTransactionNotSupportedException | Exception thrown when attempting to work with a nested transaction but nested transactions are not supported by the underlying backend. |
NoHandlerFoundException | Exception to be thrown if DispatcherPortlet is unable to determine a corresponding handler for an incoming portlet request. |
NonTransientDataAccessException | Root of the hierarchy of data access exceptions that are considered non-transient - where a retry of the same operation would fail unless the cause of the Exception is corrected. |
NonTransientDataAccessResourceException | Data access exception thrown when a resource fails completely and the failure is permanent. |
NoRollbackRuleAttribute | Tag subclass of RollbackRuleAttribute that has the opposite behavior
to the RollbackRuleAttribute superclass. |
NoSuchBeanDefinitionException | Exception thrown when a BeanFactory is asked for a bean instance name for which it cannot find a definition. |
NoSuchMessageException | Exception thrown when a message can't be resolved. |
NoSuchRequestHandlingMethodException | Exception thrown when there is no handler method ("action" method) for a specific HTTP request. |
NotAnAtAspectException | Extension of AopConfigException thrown when trying to perform an advisor generation operation on a class that is not an AspectJ annotation-style aspect. |
NotificationListenerBean | Helper class that aggregates a javax.management.NotificationListener, a javax.management.NotificationFilter, and an arbitrary handback object. |
NotificationListenerHolder | Helper class that aggregates a javax.management.NotificationListener, a javax.management.NotificationFilter, and an arbitrary handback object, as well as the names of MBeans from which the listener wishes to receive javax.management.Notification Notifications. |
NotificationListenerRegistrar | Registrar object that associates a specific javax.management.NotificationListener with one or more MBeans in an javax.management.MBeanServer (typically via a javax.management.MBeanServerConnection). |
NotificationPublisher | Simple interface allowing Spring-managed MBeans to publish JMX notifications without being aware of how those notifications are being transmitted to the javax.management.MBeanServer. |
NotificationPublisherAware | Interface to be implemented by any Spring-managed resource that is to be registered with an javax.management.MBeanServer and wishes to send JMX javax.management.Notification javax.management.Notifications. |
NoTransactionException | Exception thrown when an operation is attempted that relies on an existing transaction (such as setting rollback status) and there is no existing transaction. |
NotReadablePropertyException | Exception thrown on an attempt to get the value of a property that isn't readable, because there's no getter method. |
NotSupportedRecordFactory | Implementation of the CCI RecordFactory interface that always throws NotSupportedException. |
NotTransactional |
This @interface is deprecated.
as of Spring 3.0, in favor of moving the non-transactional test
method to a separate (non-transactional) test class or to a
@BeforeTransaction or
@AfterTransaction method.
|
NotWritablePropertyException | Exception thrown on an attempt to set the value of a property that is not writable (typically because there is no setter method). |
NullLiteral | |
NullSafeComparator<T> | A Comparator that will safely compare nulls to be lower or higher than other objects. |
NullSourceExtractor | Simple implementation of SourceExtractor that returns null
as the source metadata. |
NullValueInNestedPathException | Exception thrown when navigation of a valid nested property path encounters a NullPointerException. |
NumberFormat | Declares that a field should be formatted as a number. |
NumberFormat.Style | Common number format styles. |
NumberFormatAnnotationFormatterFactory | Formats fields annotated with the NumberFormat annotation. |
NumberFormatter | A general-purpose Number formatter. |
NumberUtils | Miscellaneous utility methods for number conversion and parsing. |
ObjectError | Encapsulates an object error, that is, a global reason for rejecting an object. |
ObjectFactory<T> | Defines a factory which can return an Object instance (possibly shared or independent) when invoked. |
ObjectFactoryCreatingFactoryBean | A FactoryBean implementation that
returns a value which is an ObjectFactory
that in turn returns a bean sourced from a BeanFactory . |
ObjectNameManager | Helper class for the creation of javax.management.ObjectName instances. |
ObjectNamingStrategy | Strategy interface that encapsulates the creation of ObjectName instances. |
ObjectOptimisticLockingFailureException | Exception thrown on an optimistic locking violation for a mapped object. |
ObjectRetrievalFailureException | Exception thrown if a mapped object could not be retrieved via its identifier. |
ObjectUtils | Miscellaneous object utility methods. |
OC4JJtaTransactionManager | Special JtaTransactionManager variant for Oracle OC4J (10.1.3 and higher). |
OC4JLoadTimeWeaver | LoadTimeWeaver implementation for OC4J's instrumentable ClassLoader. |
OncePerRequestFilter | Filter base class that guarantees to be just executed once per request, on any servlet container. |
OpAnd | Represents the boolean AND operation. |
OpDivide | Implements division operator. |
OpenEntityManagerInViewFilter | Servlet 2.3 Filter that binds a JPA EntityManager to the thread for the entire processing of the request. |
OpenEntityManagerInViewInterceptor | Spring web request interceptor that binds a JPA EntityManager to the thread for the entire processing of the request. |
OpenJpaDialect | JpaDialect implementation for
Apache OpenJPA. |
OpenJpaVendorAdapter | JpaVendorAdapter implementation for
Apache OpenJPA. |
OpenPersistenceManagerInViewFilter | Servlet 2.3 Filter that binds a JDO PersistenceManager to the thread for the entire processing of the request. |
OpenPersistenceManagerInViewInterceptor | Spring web request interceptor that binds a JDO PersistenceManager to the thread for the entire processing of the request. |
OpenSessionInViewFilter | Servlet 2.3 Filter that binds a Hibernate Session to the thread for the entire processing of the request. |
OpenSessionInViewInterceptor | Spring web request interceptor that binds a Hibernate Session to the
thread for the entire processing of the request. |
OpEQ | Implements equality operator. |
Operation | Supported operations that an OperatorOverloader can implement for any pair of operands. |
Operator | Common supertype for operators that operate on either one or two operands. |
OperatorBetween | Represents the between operator. |
OperatorInstanceof | The operator 'instanceof' checks if an object is of the class specified in the right hand operand,
in the same way that instanceof does in Java. |
OperatorMatches | Implements the matches operator. |
OperatorNot | Represents a NOT operation. |
OperatorOverloader | By default the mathematical operators Operation support simple types like numbers. |
OperatorPower | The power operator. |
OpGE | Implements greater-than-or-equal operator. |
OpGT | Implements greater-than operator. |
OpLE | Implements the less-than-or-equal operator. |
OpLT | Implements the less-than operator. |
OpMinus | The minus operator supports:
|
OpModulus | Implements the modulus operator. |
OpMultiply | Implements the multiply operator. |
OpNE | Implements the not-equal operator. |
OpOr | Represents the boolean OR operation. |
OpPlus | The plus operator will:
|
OptimisticLockingFailureException | Exception thrown on an optimistic locking violation. |
OptionsTag | Convenient tag that allows one to supply a collection of objects
that are to be rendered as 'option ' tags within a
'select ' tag. |
OptionTag | JSP tag for rendering an HTML 'option ' tag. |
OracleCallMetaDataProvider | Oracle specific implementation for the CallMetaDataProvider interface. |
OracleJdbc4NativeJdbcExtractor | A Jdbc4NativeJdbcExtractor which comes pre-configured for Oracle's JDBC driver,
specifying the following vendor-specific API types for unwrapping:
Note: This will work with any JDBC 4.0 compliant connection pool, without a need for connection pool specific setup. |
OracleLobHandler | LobHandler implementation for Oracle databases. |
OracleLobHandler.LobCallback | Internal callback interface for use with createLob. |
OracleLobHandler.OracleLobCreator | LobCreator implementation for Oracle databases. |
OracleSequenceMaxValueIncrementer | DataFieldMaxValueIncrementer that retrieves the next value of a given Oracle sequence. |
OracleTableMetaDataProvider | Oracle-specific implementation of the TableMetaDataProvider . |
Order | Annotation that defines ordering. |
OrderComparator | Comparator implementation for Ordered objects,
sorting by order value ascending (resp. |
Ordered | Interface that can be implemented by objects that should be orderable, for example in a Collection. |
OutputStreamFactory | Internal helper for exposing dummy OutputStreams to embedded databases such as Derby, preventing the creation of a log file. |
OverridingClassLoader | ClassLoader that does not always delegate to the
parent loader, as normal class loaders do. |
OxmNamespaceHandler | NamespaceHandler for the 'oxm ' namespace. |
PagedListHolder<E> | PagedListHolder is a simple state holder for handling lists of objects, separating them into pages. |
Param | Bean used to pass name-value pair parameters from a ParamTag to a
ParamAware tag. |
ParamAware | Allows implementing tag to utilize nested spring:param tags. |
ParameterDisposer | Interface to be implemented by objects that can close resources allocated by parameters like SqlLobValues. |
ParameterHandlerMapping | Implementation of the HandlerMapping
to map from a request parameter to request handler beans. |
ParameterizableViewController | Trivial controller that always returns a named view. |
ParameterizableViewController | Trivial controller that always returns a named view. |
ParameterizedBeanPropertyRowMapper<T> | ParameterizedRowMapper implementation that converts a row into a new instance
of the specified mapped target class. |
ParameterizedRowMapper<T> | Extension of the RowMapper interface,
adding type parameterization. |
ParameterizedSingleColumnRowMapper<T> | ParameterizedRowMapper implementation that converts a single column
into a single result value per row. |
ParameterMapper | Implement this interface when parameters need to be customized based on the connection. |
ParameterMappingInterceptor | Interceptor to forward a request parameter from the ActionRequest to the
RenderRequest . |
ParameterMethodNameResolver | Implementation of MethodNameResolver which supports several strategies
for mapping parameter values to the names of methods to invoke. |
ParameterNameDiscoverer | Interface to discover parameter names for methods and constructors. |
ParamTag | JSP tag for collecting name-value parameters and passing them to a
ParamAware ancestor in the tag hierarchy. |
ParsedSql | Holds information about a parsed SQL statement. |
ParseException | Represent an exception that occurs during expression parsing. |
Parser<T> | Parses text strings to produce instances of T. |
ParserContext | Context that gets passed along a bean definition parsing process, encapsulating all relevant configuration as well as state. |
ParserContext | Input provided to an expression parser that can influence an expression parsing/compilation routine. |
ParseState | Simple Stack-based structure for tracking the logical position during a parsing process. |
ParseState.Entry | Marker interface for entries into the ParseState . |
PassThroughFilterChain | Implementation of the javax.servlet.FilterConfig interface which simply passes the call through to a given Filter/FilterChain combination (indicating the next Filter in the chain along with the FilterChain that it is supposed to work on) or to a given Servlet (indicating the end of the chain). |
PassThroughSourceExtractor | Simple SourceExtractor implementation that just passes
the candidate source metadata object through for attachment. |
PasswordInputTag | Databinding-aware JSP tag for rendering an HTML 'input '
element with a 'type ' of 'password '. |
PathMatcher | Strategy interface for String -based path matching. |
PathMatchingResourcePatternResolver | A ResourcePatternResolver implementation that is able to resolve a
specified resource location path into one or more matching Resources. |
PathVariable | Annotation which indicates that a method parameter should be bound to a URI template variable. |
PatternEditor | Editor for java.util.regex.Pattern , to directly populate a Pattern property. |
PatternMatchUtils | Utility methods for simple pattern matching, in particular for Spring's typical "xxx*", "*xxx" and "*xxx*" pattern styles. |
PercentFormatter | A Number formatter for percent values. |
PerformanceMonitorInterceptor | Simple AOP Alliance MethodInterceptor for performance monitoring. |
PeriodicTrigger | A trigger for periodic task execution. |
PermissionDeniedDataAccessException | Exception thrown when the underlying resource denied a permission to access a specific element, such as a specific database table. |
PersistenceAnnotationBeanPostProcessor | BeanPostProcessor that processes javax.persistence.PersistenceUnit and javax.persistence.PersistenceContext annotations, for injection of the corresponding JPA resources javax.persistence.EntityManagerFactory and javax.persistence.EntityManager. |
PersistenceExceptionTranslationAdvisor | Spring AOP exception translation aspect for use at Repository or DAO layer level. |
PersistenceExceptionTranslationInterceptor | AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator. |
PersistenceExceptionTranslationPostProcessor | Bean post-processor that automatically applies persistence exception
translation to any bean that carries the
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). |
PersistenceExceptionTranslator | Interface implemented by Spring integrations with data access technologies that throw runtime exceptions, such as JPA, TopLink, JDO and Hibernate. |
PersistenceManagerFactoryUtils | Helper class featuring methods for JDO PersistenceManager handling, allowing for reuse of PersistenceManager instances within transactions. |
PersistenceManagerHolder | Holder wrapping a JDO PersistenceManager. |
PersistenceUnitManager | Interface that defines an abstraction for finding and managing JPA PersistenceUnitInfos. |
PersistenceUnitPostProcessor | Callback interface for post-processing a JPA PersistenceUnitInfo. |
PessimisticLockingFailureException | Exception thrown on a pessimistic locking violation. |
Phased | Interface for objects that may participate in a phased process such as lifecycle management. |
PlaceholderConfigurerSupport | Abstract base class for property resource configurers that resolve placeholders in bean definition property values. |
PlatformTransactionManager | This is the central interface in Spring's transaction infrastructure. |
PluggableSchemaResolver | EntityResolver implementation that attempts to resolve schema URLs into
local classpath resources using a set of mappings files. |
Pointcut | Core Spring pointcut abstraction. |
PointcutAdvisor | Superinterface for all Advisors that are driven by a pointcut. |
PointcutComponentDefinition | ComponentDefinition
implementation that holds a pointcut definition. |
PointcutEntry | ParseState entry representing a pointcut. |
Pointcuts | Pointcut constants for matching getters and setters, and static methods useful for manipulating and evaluating pointcuts. |
PoolingConfig | Config interface for a pooling target source. |
PortletApplicationContextUtils | Convenience methods for retrieving the root WebApplicationContext for a given PortletContext. |
PortletApplicationObjectSupport | Convenient superclass for application objects running in a Portlet ApplicationContext. |
PortletConfigAware | Interface to be implemented by any object that wishes to be notified of the PortletConfig (typically determined by the PortletApplicationContext) that it runs in. |
PortletConfigPropertySource | PropertySource that reads init parameters from a PortletConfig object. |
PortletContentGenerator | Convenient superclass for any kind of web content generator,
like AbstractController . |
PortletContextAware | Interface to be implemented by any object that wishes to be notified of the PortletContext (typically determined by the PortletApplicationContext) that it runs in. |
PortletContextAwareProcessor | BeanPostProcessor
implementation that passes the PortletContext to beans that implement
the PortletContextAware interface. |
PortletContextPropertySource | PropertySource that reads init parameters from a PortletContext object. |
PortletContextResource | Resource implementation for
javax.portlet.PortletContext resources, interpreting
relative paths within the portlet application root directory. |
PortletContextResourceLoader | ResourceLoader implementation that resolves paths as PortletContext resources, for use outside a Portlet ApplicationContext (for example, in a GenericPortletBean subclass). |
PortletContextResourcePatternResolver | PortletContext-aware subclass of PathMatchingResourcePatternResolver ,
able to find matching resources below the web application root directory
via Portlet API's PortletContext.getResourcePaths . |
PortletContextScope | Scope wrapper for a PortletContext, i.e. |
PortletModeHandlerMapping | Implementation of the HandlerMapping
interface to map from the current PortletMode to request handler beans. |
PortletModeNameViewController | Trivial controller that transforms the PortletMode to a view name. |
PortletModeParameterHandlerMapping | Implementation of the HandlerMapping
interface to map from the current PortletMode and a request parameter to
request handler beans. |
PortletMultipartResolver | Portlet version of Spring's multipart resolution strategy for file uploads as defined in RFC 1867. |
PortletRequestAttributes | Portlet-based implementation of the
RequestAttributes interface. |
PortletRequestBindingException | Fatal binding exception, thrown when we want to treat binding exceptions as unrecoverable. |
PortletRequestDataBinder | Special DataBinder to perform data binding
from portlet request parameters to JavaBeans, including support for multipart files. |
PortletRequestHandledEvent | Portlet-specific subclass of RequestHandledEvent, adding portlet-specific context information. |
PortletRequestMethodNotSupportedException | Exception thrown when a request handler does not support a specific request method. |
PortletRequestParameterPropertyValues | PropertyValues implementation created from parameters in a PortletRequest. |
PortletRequestUtils | Parameter extraction methods, for an approach distinct from data binding, in which parameters of specific types are required. |
PortletSessionRequiredException | Exception thrown when a portlet content generator requires a pre-existing session. |
PortletUtils | Miscellaneous utilities for portlet applications. |
PortletWebRequest | WebRequest adapter
for a javax.portlet.PortletRequest. |
PortletWrappingController | Controller implementation that wraps a portlet instance which it manages
internally. |
PostgresCallMetaDataProvider | Oracle specific implementation for the CallMetaDataProvider interface. |
PostgreSQLSequenceMaxValueIncrementer | DataFieldMaxValueIncrementer that retrieves the next value of a given PostgreSQL sequence. |
PostgresTableMetaDataProvider | The PostgreSQL specific implementation of the TableMetaDataProvider . |
PreferencesPlaceholderConfigurer | Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's
Preferences API (java.util.prefs ). |
PreparedStatementCallback<T> | Generic callback interface for code that operates on a PreparedStatement. |
PreparedStatementCreator | One of the two central callback interfaces used by the JdbcTemplate class. |
PreparedStatementCreatorFactory | Helper class that efficiently creates multiple PreparedStatementCreator
objects with different parameters based on a SQL statement and a single
set of parameter declarations. |
PreparedStatementSetter | General callback interface used by the JdbcTemplate class. |
Primary | Indicates that a bean should be given preference when multiple candidates are qualified to autowire a single-valued dependency. |
Printer<T> | Prints objects of type T for display. |
PrioritizedParameterNameDiscoverer | ParameterNameDiscoverer implementation that tries several ParameterNameDiscoverers in succession. |
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. |
Problem | Represents a problem with a bean definition configuration. |
ProblemCollector | TODO SPR-7420: document |
ProblemReporter | SPI interface allowing tools and other external processes to handle errors and warnings reported during bean definition parsing. |
ProducerCallback<T> | Callback for sending a message to a JMS destination. |
Profile | Indicates that a component is eligible for registration when one or more #value specified profiles are active. |
ProfileValueSource | Strategy interface for retrieving profile values for a given testing environment. |
ProfileValueSourceConfiguration |
ProfileValueSourceConfiguration is a class-level annotation which is used to
specify what type of |
ProfileValueUtils | General utility methods for working with profile values. |
Projection | Represents projection, where a given operation is performed on all elements in some input sequence, returning a new sequence of the same size. |
Propagation | Enumeration that represents transaction propagation behaviors for use
with the Transactional annotation, corresponding to the
TransactionDefinition interface. |
PropertiesBeanDefinitionReader | Bean definition reader for a simple properties format. |
PropertiesEditor | Custom java.beans.PropertyEditor for Properties objects. |
PropertiesFactoryBean | Allows for making a properties file from a classpath location available as Properties instance in a bean factory. |
PropertiesLoaderSupport | Base class for JavaBean-style components that need to load properties from one or more resources. |
PropertiesLoaderUtils | Convenient utility methods for loading of java.util.Properties ,
performing standard handling of input streams. |
PropertiesMethodNameResolver | The most flexible out-of-the-box implementation of the MethodNameResolver
interface. |
PropertiesPersister | Strategy interface for persisting java.util.Properties ,
allowing for pluggable parsing strategies. |
PropertiesPropertySource | PropertySource implementation that extracts properties from a java.util.Properties object. |
PropertyAccessException | Superclass for exceptions related to a property access, such as type mismatch or invocation target exception. |
PropertyAccessor | Common interface for classes that can access named properties
(such as bean properties of an object or fields in an object)
Serves as base interface for BeanWrapper . |
PropertyAccessor | A property accessor is able to read (and possibly write) to object properties. |
PropertyAccessorFactory | Simple factory facade for obtaining PropertyAccessor instances,
in particular for BeanWrapper instances. |
PropertyAccessorUtils | Utility methods for classes that perform bean property access
according to the PropertyAccessor interface. |
PropertyBatchUpdateException | Combined exception, composed of individual PropertyAccessException instances. |
PropertyComparator | PropertyComparator performs a comparison of two beans, evaluating the specified bean property via a BeanWrapper. |
PropertyEditorRegistrar | Interface for strategies that register custom
java.beans.PropertyEditor property editors with a
property editor registry . |
PropertyEditorRegistry | Encapsulates methods for registering JavaBeans PropertyEditor PropertyEditors. |
PropertyEditorRegistrySupport | Base implementation of the PropertyEditorRegistry interface. |
PropertyEntry | ParseState entry representing a JavaBean property. |
PropertyOrFieldReference | Represents a simple property or field reference. |
PropertyOverrideConfigurer | Property resource configurer that overrides bean property values in an application context definition. |
PropertyPathFactoryBean | FactoryBean that evaluates a property path on a given target object. |
PropertyPlaceholderConfigurer | PlaceholderConfigurerSupport subclass that resolves ${...} placeholders
against local properties and/or system properties
and environment variables. |
PropertyPlaceholderHelper | Utility class for working with Strings that have placeholder values in them. |
PropertyPlaceholderHelper.PlaceholderResolver | Strategy interface used to resolve replacement values for placeholders contained in Strings. |
PropertyResolver | Interface for resolving properties against any underlying source. |
PropertyResourceConfigurer | Allows for configuration of individual bean property values from a property resource, i.e. |
PropertySource<T> | Abstract base class representing a source of key/value property pairs. |
PropertySource.StubPropertySource | PropertySource to be used as a placeholder in cases where an actual
property source cannot be eagerly initialized at application context
creation time. |
PropertySources | Holder containing one or more PropertySource objects. |
PropertySourcesPlaceholderConfigurer | Specialization of PlaceholderConfigurerSupport
Local properties are added as a property source in any case. |
PropertySourcesPropertyResolver | PropertyResolver implementation that resolves property values against
an underlying set of PropertySources . |
PropertyTypeDescriptor | TypeDescriptor extension that exposes additional annotations
as conversion metadata: namely, annotations on other accessor methods
(getter/setter) and on the underlying field, if found. |
PropertyValue | Object to hold information and value for an individual bean property. |
PropertyValues | Holder containing one or more PropertyValue objects,
typically comprising one update for a specific target bean. |
PropertyValuesEditor | java.beans.PropertyEditor Editor for a PropertyValues object. |
PrototypeAspectInstanceFactory | AspectInstanceFactory backed by a BeanFactory-provided prototype, enforcing prototype semantics. |
PrototypeTargetSource | TargetSource that creates a new instance of the target bean for each request, destroying each instance on release (after each request). |
ProviderCreatingFactoryBean | A FactoryBean implementation that
returns a value which is a JSR-330 javax.inject.Provider that in turn
returns a bean sourced from a BeanFactory . |
ProxyConfig | Convenience superclass for configuration used in creating proxies, to ensure that all proxy creators have consistent properties. |
ProxyCreationContext | Holder for the current proxy creation context, as exposed by auto-proxy creators
such as AbstractAdvisorAutoProxyCreator . |
ProxyCreatorSupport | Base class for proxy factories. |
ProxyFactory | Factory for AOP proxies for programmatic use, rather than via a bean factory. |
ProxyFactoryBean | FactoryBean implementation that builds an
AOP proxy based on beans in Spring BeanFactory . |
ProxyFactoryBean | FactoryBean that creates a Proxy java.net.Proxy. |
ProxyMethodInvocation | Extension of the AOP Alliance org.aopalliance.intercept.MethodInvocation interface, allowing access to the proxy that the method invocation was made through. |
QualifiedIdentifier | Represents a dot separated sequence of strings that indicate a package qualified type reference. |
Qualifier | This annotation may be used on a field or parameter as a qualifier for candidate beans when autowiring. |
QualifierAnnotationAutowireCandidateResolver | AutowireCandidateResolver implementation that matches bean definition qualifiers
against qualifier annotations on the field or parameter to be autowired. |
QualifierEntry | ParseState entry representing an autowire candidate qualifier. |
QuartzJobBean | Simple implementation of the Quartz Job interface, applying the passed-in JobDataMap and also the SchedulerContext as bean property values. |
QuickTargetSourceCreator | Convenient TargetSourceCreator using bean name prefixes to create one of three
well-known TargetSource types:
|
RadioButtonsTag | Databinding-aware JSP tag for rendering multiple HTML 'input '
elements with a 'type ' of 'radio '. |
RadioButtonTag | Databinding-aware JSP tag for rendering an HTML 'input '
element with a 'type ' of 'radio '. |
RawTargetAccess | Marker for AOP proxy interfaces (in particular: introduction interfaces) that explicitly intend to return the raw target object (which would normally get replaced with the proxy object when returned from a method invocation). |
RdbmsOperation | An "RDBMS operation" is a multi-threaded, reusable object representing a query, update, or stored procedure call. |
ReadableInstantPrinter | Prints JodaTime ReadableInstant instances using a DateTimeFormatter. |
ReadablePartialPrinter | Prints JodaTime ReadablePartial instances using a DateTimeFormatter. |
ReaderContext | Context that gets passed along a bean definition reading process, encapsulating all relevant configuration as well as state. |
ReaderEventListener | Interface that receives callbacks for component, alias and import registrations during a bean definition reading process. |
RealLiteral | |
RecordCreator | Callback interface for creating a CCI Record instance, usually based on the passed-in CCI RecordFactory. |
RecordExtractor<T> | Callback interface for extracting a result object from a CCI Record instance. |
RecordTypeNotSupportedException | Exception thrown when the creating of a CCI Record failed because the connector doesn't support the desired CCI Record type. |
RecoverableDataAccessException | Data access exception thrown when a previously failed operation might be able to succeed if the application performs some recovery steps and retries the entire transaction or in the case of a distributed transaction, the transaction branch. |
RedirectView | View that redirects to an absolute, context relative, or current request relative URL. |
ReflectionHelper | Utility methods used by the reflection resolver code to discover the appropriate methods/constructors and fields that should be used in expressions. |
ReflectionHelper.ArgsMatchKind | |
ReflectionHelper.ArgumentsMatchInfo | An instance of ArgumentsMatchInfo describes what kind of match was achieved between two sets of arguments - the set that a method/constructor is expecting and the set that are being supplied at the point of invocation. |
ReflectionTestUtils | ReflectionTestUtils is a collection of reflection-based utility methods for use in unit and integration testing scenarios. |
ReflectionUtils | Simple utility class for working with the reflection API and handling reflection exceptions. |
ReflectionUtils.FieldCallback | Callback interface invoked on each field in the hierarchy. |
ReflectionUtils.FieldFilter | Callback optionally used to filter fields to be operated on by a field callback. |
ReflectionUtils.MethodCallback | Action to take on each method. |
ReflectionUtils.MethodFilter | Callback optionally used to method fields to be operated on by a method callback. |
ReflectiveAspectJAdvisorFactory | Factory that can create Spring AOP Advisors given AspectJ classes from classes honoring the AspectJ 5 annotation syntax, using reflection to invoke the corresponding advice methods. |
ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor | Synthetic advisor that instantiates the aspect. |
ReflectiveConstructorResolver | A constructor resolver that uses reflection to locate the constructor that should be invoked |
ReflectiveLoadTimeWeaver | LoadTimeWeaver which uses reflection to delegate to an underlying ClassLoader
with well-known transformation hooks. |
ReflectiveMethodInvocation | Spring's implementation of the AOP Alliance
org.aopalliance.intercept.MethodInvocation interface,
implementing the extended
ProxyMethodInvocation interface. |
ReflectiveMethodResolver | A method resolver that uses reflection to locate the method that should be invoked. |
ReflectivePropertyAccessor | Simple PropertyAccessor that uses reflection to access properties for reading and writing. |
Refreshable | Interface to be implemented by dynamic target objects, which support reloading and optionally polling for updates. |
RefreshableScriptTargetSource | Subclass of BeanFactoryRefreshableTargetSource that determines whether
a refresh is required through the given ScriptFactory . |
RegexPatternTypeFilter | A simple filter for matching a fully-qualified class name with a regex Pattern. |
RegexpMethodPointcutAdvisor | Convenient class for regexp method pointcuts that hold an Advice,
making them an Advisor . |
ReloadableResourceBundleMessageSource | MessageSource implementation that
accesses resource bundles using specified basenames. |
ReloadableResourceBundleMessageSource.PropertiesHolder | PropertiesHolder for caching. |
RemoteAccessException | Generic remote access exception. |
RemoteAccessor | Abstract base class for classes that access a remote service. |
RemoteConnectFailureException | RemoteAccessException subclass to be thrown when no connection could be established with a remote service. |
RemoteExporter | Abstract base class for classes that export a remote service. |
RemoteInvocation | Encapsulates a remote invocation, providing core method invocation properties in a serializable fashion. |
RemoteInvocationBasedAccessor | Abstract base class for remote service accessors that are based
on serialization of RemoteInvocation objects. |
RemoteInvocationBasedExporter | Abstract base class for remote service exporters that are based
on deserialization of RemoteInvocation objects. |
RemoteInvocationExecutor | Strategy interface for executing a RemoteInvocation on a target object. |
RemoteInvocationFactory | Strategy interface for creating a RemoteInvocation from an AOP Alliance
org.aopalliance.intercept.MethodInvocation. |
RemoteInvocationFailureException | RemoteAccessException subclass to be thrown when the execution of the target method failed on the server side, for example when a method was not found on the target object. |
RemoteInvocationResult | Encapsulates a remote invocation result, holding a result value or an exception. |
RemoteInvocationSerializingExporter | Abstract base class for remote service exporters that explicitly deserialize
RemoteInvocation objects and serialize
RemoteInvocationResult objects,
for example Spring's HTTP invoker. |
RemoteInvocationTraceInterceptor | AOP Alliance MethodInterceptor for tracing remote invocations. |
RemoteInvocationUtils | General utilities for handling remote invocations. |
RemoteLookupFailureException | RemoteAccessException subclass to be thrown in case of a lookup failure, typically if the lookup happens on demand for each method invocation. |
RemoteProxyFailureException | RemoteAccessException subclass to be thrown in case of a failure within the client-side proxy for a remote service, for example when a method was not found on the underlying RMI stub. |
RemotingSupport | Generic support base class for remote accessor and exporters, providing common bean ClassLoader handling. |
RenderMapping | Annotation for mapping Portlet render requests onto handler methods. |
Repeat | Test annotation to indicate that a test method should be invoked repeatedly. |
ReplaceOverride | Extension of MethodOverride that represents an arbitrary override of a method by the IoC container. |
Repository | Indicates that an annotated class is a "Repository" (or "DAO"). |
RequestAttributes | Abstraction for accessing attribute objects associated with a request. |
RequestBody | Annotation which indicates that a method parameter should be bound to the web request body. |
RequestCallback | Callback interface for code that operates on a ClientHttpRequest . |
RequestContext | Context holder for request-specific state, like current web application context, current locale, current theme, and potential binding errors. |
RequestContextAwareTag | Superclass for all tags that require a RequestContext . |
RequestContextFilter | Servlet 2.3 Filter that exposes the request to the current thread,
through both LocaleContextHolder and
RequestContextHolder . |
RequestContextHolder | Holder class to expose the web request in the form of a thread-bound
RequestAttributes object. |
RequestContextListener | Servlet 2.4+ listener that exposes the request to the current thread,
through both LocaleContextHolder and
RequestContextHolder . |
RequestContextUtils | Utility class for easy access to request-specific state which has been
set by the DispatcherServlet . |
RequestHandledEvent | Event raised when a request is handled within an ApplicationContext. |
RequestHeader | Annotation which indicates that a method parameter should be bound to a web request header. |
RequestMapping | Annotation for mapping web requests onto specific handler classes and/or handler methods. |
RequestMethod | Java 5 enumeration of HTTP request methods. |
RequestParam | Annotation which indicates that a method parameter should be bound to a web request parameter. |
RequestScope | Request-backed Scope
implementation. |
RequestToViewNameTranslator | Strategy interface for translating an incoming javax.servlet.http.HttpServletRequest into a logical view name when no view name is explicitly supplied. |
Required | Marks a method (typically a JavaBean setter method) as being 'required': that is, the setter method must be configured to be dependency-injected with a value. |
RequiredAnnotationBeanPostProcessor | BeanPostProcessor implementation
that enforces required JavaBean properties to have been configured. |
Resource | Interface for a resource descriptor that abstracts from the actual type of underlying resource, such as a file or class path resource. |
ResourceAccessException | Exception thrown when an I/O error occurs. |
ResourceAdapterApplicationContext | ApplicationContext implementation
for a JCA ResourceAdapter. |
ResourceAdapterFactoryBean | FactoryBean that bootstraps
the specified JCA 1.5 javax.resource.spi.ResourceAdapter,
starting it with a local javax.resource.spi.BootstrapContext
and exposing it for bean references. |
ResourceAllocationException | Runtime exception mirroring the JMS ResourceAllocationException. |
ResourceArrayPropertyEditor | Editor for Resource arrays, to
automatically convert String location patterns
(e.g. |
ResourceAwareController | Extension of the Portlet Controller interface that allows
for handling Portlet 2.0 resource requests as well. |
ResourceBundleEditor | java.beans.PropertyEditor implementation for java.util.ResourceBundle ResourceBundles. |
ResourceBundleMessageSource | MessageSource implementation that
accesses resource bundles using specified basenames. |
ResourceBundleThemeSource | ThemeSource implementation that looks up an individual
java.util.ResourceBundle per theme. |
ResourceBundleViewResolver | ViewResolver implementation
that uses bean definitions in a ResourceBundle, specified by
the bundle basename. |
ResourceDatabasePopulator | Populates a database from SQL scripts defined in external resources. |
ResourceEditor | java.beans.PropertyEditor Editor for Resource
descriptors, to automatically convert String locations
e.g. |
ResourceEditorRegistrar | PropertyEditorRegistrar implementation that populates a given
PropertyEditorRegistry
(typically a BeanWrapper used for bean
creation within an ApplicationContext )
with resource editors. |
ResourceEntityResolver | EntityResolver implementation that tries to resolve entity references
through a ResourceLoader (usually,
relative to the resource base of an ApplicationContext), if applicable. |
ResourceHolder | Generic interface to be implemented by resource holders. |
ResourceHolderSupport | Convenient base class for resource holders. |
ResourceHolderSynchronization<H extends ResourceHolder, K> | TransactionSynchronization implementation that manages a
ResourceHolder bound through TransactionSynchronizationManager . |
ResourceHttpMessageConverter | Implementation of HttpMessageConverter that can read and write Resources . |
ResourceHttpRequestHandler | HttpRequestHandler that serves static resources optimized for superior browser performance
(according to the guidelines of Page Speed, YSlow, etc.) by allowing for flexible cache settings
("cacheSeconds" property , last-modified support). |
ResourceLoader | Strategy interface for loading resources (e.. |
ResourceLoaderAware | Interface to be implemented by any object that wishes to be notified of the ResourceLoader (typically the ApplicationContext) that it runs in. |
ResourceLoaderClassLoadHelper | Wrapper that adapts from the Quartz ClassLoadHelper interface
onto Spring's ResourceLoader interface. |
ResourceMapping | Annotation for mapping Portlet resource requests onto handler methods. |
ResourceOverridingShadowingClassLoader | Subclass of ShadowingClassLoader that overrides attempts to locate certain files. |
ResourcePatternResolver | Strategy interface for resolving a location pattern (for example, an Ant-style path pattern) into Resource objects. |
ResourcePatternUtils | Utility class for determining whether a given URL is a resource location that can be loaded via a ResourcePatternResolver. |
ResourceScriptSource | ScriptSource implementation
based on Spring's Resource
abstraction. |
ResourceServlet | Simple servlet that can expose an internal resource, including a default URL if the specified resource is not found. |
ResourceTransactionManager | Extension of the PlatformTransactionManager
interface, indicating a native resource transaction manager, operating on a single
target resource. |
ResourceUtils | Utility methods for resolving resource locations to files in the file system. |
ResponseBody | Annotation which indicates that a method return value should be bound to the web response body. |
ResponseEntity<T> | Extension of HttpEntity that adds a HttpStatus status code. |
ResponseErrorHandler | Strategy interface used by the RestTemplate to determine whether a particular response has an error or not. |
ResponseExtractor<T> | Generic callback interface used by RestTemplate 's retrieval methods
Implementations of this interface perform the actual work of extracting data
from a ClientHttpResponse , but don't need to worry about exception
handling or closing resources. |
ResponseStatus | Marks a method or exception class with the status code and reason that should be returned. |
ResponseStatusExceptionResolver | Implementation of the HandlerExceptionResolver
interface that uses the @ResponseStatus annotation to map exceptions to HTTP status codes. |
RestClientException | Base class for exceptions thrown by RestTemplate whenever it encounters client-side HTTP errors. |
RestGatewaySupport | Convenient super class for application classes that need REST access. |
RestOperations | Interface specifying a basic set of RESTful operations. |
RestTemplate | The central class for client-side HTTP access. |
ResultSetExtractor<T> | Callback interface used by JdbcTemplate 's query methods. |
ResultSetSupportingSqlParameter | Common base class for ResultSet-supporting SqlParameters like
SqlOutParameter and SqlReturnResultSet . |
ResultSetWrappingSqlRowSet | Default implementation of Spring's SqlRowSet interface. |
ResultSetWrappingSqlRowSetMetaData | Default implementation of Spring's SqlRowSetMetaData interface. |
RmiBasedExporter | Convenient superclass for RMI-based remote exporters. |
RmiClientInterceptor | org.aopalliance.intercept.MethodInterceptor for accessing conventional RMI services or RMI invokers. |
RmiClientInterceptorUtils | Factored-out methods for performing invocations within an RMI client. |
RmiInvocationHandler | Interface for RMI invocation handlers instances on the server, wrapping exported services. |
RmiProxyFactoryBean | FactoryBean for RMI proxies, supporting both conventional RMI services
and RMI invokers. |
RmiRegistryFactoryBean | FactoryBean that locates a java.rmi.registry.Registry and
exposes it for bean references. |
RmiServiceExporter | RMI exporter that exposes the specified service as RMI object with the specified name. |
Rollback | Test annotation to indicate whether or not the transaction for the annotated test method should be rolled back after the test method has completed. |
RollbackRuleAttribute | Rule determining whether or not a given exception (and any subclasses) should cause a rollback. |
RootBeanDefinition | A root bean definition represents the merged bean definition that backs a specific bean in a Spring BeanFactory at runtime. |
RootClassFilter | Simple ClassFilter implementation that passes classes (and optionally subclasses) |
RowCallbackHandler | An interface used by JdbcTemplate for processing rows of a
java.sql.ResultSet on a per-row basis. |
RowCountCallbackHandler | Implementation of RowCallbackHandler. |
RowMapper<T> | An interface used by JdbcTemplate for mapping rows of a
java.sql.ResultSet on a per-row basis. |
RowMapperResultSetExtractor<T> | Adapter implementation of the ResultSetExtractor interface that delegates to a RowMapper which is supposed to create an object for each row. |
RssChannelHttpMessageConverter | Implementation of HttpMessageConverter that can read and write RSS feeds. |
RuleBasedTransactionAttribute | TransactionAttribute implementation that works out whether a given exception should cause transaction rollback by applying a number of rollback rules, both positive and negative. |
RunAfterTestClassCallbacks | RunAfterTestClassCallbacks is a custom JUnit 4.5+
Statement which allows the Spring TestContext Framework to
be plugged into the JUnit execution chain by calling
afterTestClass() on the supplied
TestContextManager . |
RunAfterTestMethodCallbacks | RunAfterTestMethodCallbacks is a custom JUnit 4.5+
Statement which allows the Spring TestContext Framework to
be plugged into the JUnit execution chain by calling
TestContextManager#afterTestMethod(Object, Method) afterTestMethod()
on the supplied TestContextManager . |
RunBeforeTestClassCallbacks | RunBeforeTestClassCallbacks is a custom JUnit 4.5+
Statement which allows the Spring TestContext Framework to
be plugged into the JUnit execution chain by calling
beforeTestClass() on the
supplied TestContextManager . |
RunBeforeTestMethodCallbacks | RunBeforeTestMethodCallbacks is a custom JUnit 4.5+
Statement which allows the Spring TestContext Framework to
be plugged into the JUnit execution chain by calling
beforeTestMethod() on the supplied TestContextManager . |
RuntimeBeanNameReference | Immutable placeholder class used for a property value object when it's a reference to another bean name in the factory, to be resolved at runtime. |
RuntimeBeanReference | Immutable placeholder class used for a property value object when it's a reference to another bean in the factory, to be resolved at runtime. |
SavepointManager | Interface that specifies an API to programmatically manage transaction savepoints in a generic fashion. |
SaxResourceUtils | Convenient utility methods for dealing with SAX. |
ScannedGenericBeanDefinition | Extension of the GenericBeanDefinition
class, based on an ASM ClassReader, with support for annotation metadata exposed
through the AnnotatedBeanDefinition interface. |
Scheduled | Annotation that marks a method to be scheduled. |
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. |
ScheduledExecutorFactoryBean | FactoryBean that sets up
a JDK 1.5 java.util.concurrent.ScheduledExecutorService
(by default: a java.util.concurrent.ScheduledThreadPoolExecutor)
and exposes it for bean references. |
ScheduledExecutorTask | JavaBean that describes a scheduled executor task, consisting of the Runnable and a delay plus period. |
ScheduledMethodRunnable | Variant of MethodInvokingRunnable meant to be used for processing
of no-arg scheduled methods. |
ScheduledTaskRegistrar | Helper bean for registering tasks with a TaskScheduler ,
typically using cron expressions. |
ScheduledTasksBeanDefinitionParser | Parser for the 'scheduled-tasks' element of the scheduling namespace. |
ScheduledTimerListener | JavaBean that describes a scheduled TimerListener, consisting of the TimerListener itself (or a Runnable to create a TimerListener for) and a delay plus period. |
ScheduledTimerTask |
This class is deprecated.
as of Spring 3.0, in favor of the scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService
|
SchedulerAccessor | Common base class for accessing a Quartz Scheduler, i.e. |
SchedulerAccessorBean | Spring bean-style class for accessing a Quartz Scheduler, i.e. |
SchedulerBeanDefinitionParser | Parser for the 'scheduler' element of the 'task' namespace. |
SchedulerContextAware | Callback interface to be implemented by Spring-managed Quartz artifacts that need access to the SchedulerContext (without having natural access to it). |
SchedulerFactoryBean | FactoryBean that creates and configures a Quartz org.quartz.Scheduler,
manages its lifecycle as part of the Spring application context, and exposes the
Scheduler as bean reference for dependency injection. |
SchedulingAwareRunnable | Extension of the Runnable interface, adding special callbacks for long-running operations. |
SchedulingException | General exception to be thrown on scheduling failures, such as the scheduler already having shut down. |
SchedulingTaskExecutor | A TaskExecutor extension exposing
scheduling characteristics that are relevant to potential task submitters. |
Scope | Strategy interface used by a ConfigurableBeanFactory ,
representing a target scope to hold bean instances in. |
Scope | When used as a type-level annotation in conjunction with the Component
annotation, indicates the name of a scope to use for instances of the annotated
type. |
ScopedBeanInterceptor | Hibernate3 interceptor used for getting the proper entity name for scoped beans. |
ScopedObject | An AOP introduction interface for scoped objects. |
ScopedProxyFactoryBean | Convenient proxy factory bean for scoped objects. |
ScopedProxyMode | Enumerates the various scoped-proxy options. |
ScopedProxyUtils | Utility class for creating a scoped proxy. |
ScopeMetadata | Describes scope characteristics for a Spring-managed bean including the scope name and the scoped-proxy behavior. |
ScopeMetadataResolver | Strategy interface for resolving the scope of bean definitions. |
ScriptCompilationException | Exception to be thrown on script compilation failure. |
ScriptFactory | Script definition interface, encapsulating the configuration
of a specific script as well as a factory method for
creating the actual scripted Java Object . |
ScriptFactoryPostProcessor | BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it. |
ScriptingDefaultsParser | |
ScriptSource | Interface that defines the source of a script. |
ScriptStatementFailedException | Thrown by ResourceDatabasePopulator if a statement in one of its SQL scripts
failed when executing it against the target database. |
SecurityContextProvider | Provider of the security context of the code running inside the bean factory. |
Selection | Represents selection over a map or collection. |
SelectTag | Databinding-aware JSP tag that renders an HTML 'select '
element. |
SelfNaming | Interface that allows infrastructure components to provide their own
ObjectName s to the MBeanExporter . |
SerializationFailedException | Wrapper for the native IOException (or similar) when a
Serializer or
Deserializer failed. |
SerializationUtils | Static utilities for serialization and deserialization. |
Serializer<T> | A strategy interface for streaming an object to an OutputStream. |
SerializingConverter | A {@Link Converter} that delegates to a Serializer
to convert an object to a byte array. |
ServerHttpRequest | Represents a server-side HTTP request. |
ServerHttpResponse | Represents a server-side HTTP response. |
Service | Indicates that an annotated class is a "Service" (e.g. |
ServiceFactoryBean | FactoryBean that exposes the
'primary' service for the configured service class, obtained through
the JDK 1.6 java.util.ServiceLoader facility. |
ServiceListFactoryBean | FactoryBean that exposes all
services for the configured service class, represented as a List of service objects,
obtained through the JDK 1.6 java.util.ServiceLoader facility. |
ServiceLoaderFactoryBean | FactoryBean that exposes the
JDK 1.6 java.util.ServiceLoader for the configured service 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 . |
ServletConfigAware | Interface to be implemented by any object that wishes to be notified of the ServletConfig (typically determined by the WebApplicationContext) that it runs in. |
ServletConfigPropertySource | PropertySource that reads init parameters from a ServletConfig object. |
ServletContextAttributeExporter | Exporter that takes Spring-defined objects and exposes them as ServletContext attributes. |
ServletContextAttributeFactoryBean | FactoryBean that fetches a specific, existing ServletContext attribute. |
ServletContextAware | Interface to be implemented by any object that wishes to be notified of the ServletContext (typically determined by the WebApplicationContext) that it runs in. |
ServletContextAwareProcessor | BeanPostProcessor
implementation that passes the ServletContext to beans that implement
the ServletContextAware interface. |
ServletContextFactoryBean | This class is deprecated. as of Spring 3.0, since "servletContext" is now available as a default bean in every WebApplicationContext |
ServletContextParameterFactoryBean | FactoryBean that retrieves a specific ServletContext init parameter
(that is, a "context-param" defined in web.xml ). |
ServletContextPropertyPlaceholderConfigurer |
This class is deprecated.
in Spring 3.1 in favor of PropertySourcesPlaceholderConfigurer
in conjunction with DefaultWebEnvironment .
|
ServletContextPropertySource | PropertySource that reads init parameters from a ServletContext object. |
ServletContextRequestLoggingFilter | Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log. |
ServletContextResource | Resource implementation for
javax.servlet.ServletContext resources, interpreting
relative paths within the web application root directory. |
ServletContextResourceLoader | ResourceLoader implementation that resolves paths as ServletContext resources, for use outside a WebApplicationContext (for example, in an HttpServletBean or GenericFilterBean subclass). |
ServletContextResourcePatternResolver | ServletContext-aware subclass of PathMatchingResourcePatternResolver ,
able to find matching resources below the web application root directory
via Servlet 2.3's ServletContext.getResourcePaths . |
ServletContextScope | Scope wrapper for a ServletContext, i.e. |
ServletEndpointSupport |
This class is deprecated.
in favor of JAX-WS support in org.springframework.remoting.jaxws
|
ServletForwardingController | Spring Controller implementation that forwards to a named servlet, i.e. |
ServletRequestAttributes | Servlet-based implementation of the RequestAttributes interface. |
ServletRequestBindingException | Fatal binding exception, thrown when we want to treat binding exceptions as unrecoverable. |
ServletRequestDataBinder | Special DataBinder to perform data binding
from servlet request parameters to JavaBeans, including support for multipart files. |
ServletRequestHandledEvent | Servlet-specific subclass of RequestHandledEvent, adding servlet-specific context information. |
ServletRequestParameterPropertyValues | PropertyValues implementation created from parameters in a ServletRequest. |
ServletRequestUtils | Parameter extraction methods, for an approach distinct from data binding, in which parameters of specific types are required. |
ServletServerHttpRequest | ServerHttpRequest implementation that is based on a HttpServletRequest. |
ServletServerHttpResponse | ServerHttpResponse implementation that is based on a HttpServletResponse. |
ServletWebRequest | WebRequest adapter for an javax.servlet.http.HttpServletRequest. |
ServletWrappingController | Spring Controller implementation that wraps a servlet instance which it manages internally. |
ServletWrappingPortletContext | Mock implementation of the javax.portlet.PortletContext interface, wrapping an underlying javax.servlet.ServletContext. |
SessionAttributes | Annotation that indicates the session attributes that a specific handler uses. |
SessionAttributeStore | Strategy interface for storing model attributes in a backend session. |
SessionAwareMessageListener<M extends Message> | Variant of the standard JMS javax.jms.MessageListener interface, offering not only the received Message but also the underlying JMS Session object. |
SessionCallback<T> | Callback for executing any number of operations on a provided Session. |
SessionFactoryUtils | Helper class featuring methods for Hibernate Session handling, allowing for reuse of Hibernate Session instances within transactions. |
SessionHolder | Session holder, wrapping a Hibernate Session and a Hibernate Transaction. |
SessionLocaleResolver | Implementation of LocaleResolver that uses a locale attribute in the user's session in case of a custom setting, with a fallback to the specified default locale or the request's accept-header locale. |
SessionProxy | Subinterface of javax.jms.Session to be implemented by Session proxies. |
SessionScope | Session-backed Scope
implementation. |
SessionStatus | Simple interface that can be injected into handler methods, allowing them to signal that their session processing is complete. |
SessionThemeResolver | Implementation of ThemeResolver that uses a theme attribute in the user's session in case of a custom setting, with a fallback to the default theme. |
SetFactoryBean | Simple factory for shared Set instances. |
ShadowingClassLoader | ClassLoader decorator that shadows an enclosing ClassLoader, applying registered transformers to all affected classes. |
ShallowEtagHeaderFilter | javax.servlet.Filter that generates an ETag value based on the content on the response. |
SharedEntityManagerBean | FactoryBean that exposes a shared JPA javax.persistence.EntityManager
reference for a given EntityManagerFactory. |
SharedEntityManagerCreator | Factory for a shareable JPA javax.persistence.EntityManager for a given javax.persistence.EntityManagerFactory. |
ShortCodedLabeledEnum | This class is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
SimpleAliasRegistry | Simple implementation of the AliasRegistry interface. |
SimpleApplicationEventMulticaster | Simple implementation of the ApplicationEventMulticaster interface. |
SimpleAspectInstanceFactory | Implementation of AspectInstanceFactory that creates a new instance
of the specified aspect class for every getAspectInstance() call. |
SimpleAsyncTaskExecutor | TaskExecutor implementation that fires up a new Thread for each task,
executing it asynchronously. |
SimpleAutowireCandidateResolver | AutowireCandidateResolver implementation to use when no annotation
support is available. |
SimpleBeanDefinitionRegistry | Simple implementation of the BeanDefinitionRegistry interface. |
SimpleBeanFactoryAwareAspectInstanceFactory | Implementation of AspectInstanceFactory that locates the aspect from the
BeanFactory using a configured bean name. |
SimpleBeanTargetSource | Simple TargetSource implementation,
freshly obtaining the specified target bean from its containing
Spring BeanFactory . |
SimpleBootstrapContext | Simple implementation of the JCA 1.5 javax.resource.spi.BootstrapContext interface, used for bootstrapping a JCA ResourceAdapter in a local environment. |
SimpleBurlapServiceExporter | HTTP request handler that exports the specified service bean as Burlap service endpoint, accessible via a Burlap proxy. |
SimpleCacheManager | Simple cache manager working against a given collection of caches. |
SimpleClientHttpRequestFactory | ClientHttpRequestFactory implementation that uses standard J2SE facilities. |
SimpleConnectionHandle | Simple implementation of the ConnectionHandle interface,
containing a given JDBC Connection. |
SimpleConstructorNamespaceHandler | Simple NamespaceHandler implementation that maps custom
attributes directly through to bean properties. |
SimpleControllerHandlerAdapter | Adapter to use the Controller workflow interface with the generic DispatcherPortlet. |
SimpleControllerHandlerAdapter | Adapter to use the plain Controller workflow interface with
the generic DispatcherServlet . |
SimpleDriverDataSource | Simple implementation of the standard JDBC javax.sql.DataSource interface,
configuring a plain old JDBC java.sql.Driver via bean properties, and returning
a new java.sql.Connection from every getConnection call. |
SimpleFormController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
SimpleFormController | This class is deprecated. as of Spring 3.0, in favor of annotated controllers |
SimpleHessianServiceExporter | HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy. |
SimpleHttpInvokerRequestExecutor | HttpInvokerRequestExecutor implementation that uses standard J2SE facilities to execute POST requests, without support for HTTP authentication or advanced configuration options. |
SimpleHttpInvokerServiceExporter | HTTP request handler that exports the specified service bean as HTTP invoker service endpoint, accessible via an HTTP invoker proxy. |
SimpleHttpServerFactoryBean | FactoryBean that creates a simple
HTTP server, based on the HTTP server that is included in Sun's JRE 1.6. |
SimpleHttpServerJaxWsServiceExporter | Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS javax.jws.WebService annotation) and exporting them through the HTTP server included in Sun's JDK 1.6. |
SimpleInstantiationStrategy | Simple object instantiation strategy for use in a BeanFactory. |
SimpleInstrumentableClassLoader | Simplistic implementation of an instrumentable ClassLoader . |
SimpleJaxWsServiceExporter | Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS javax.jws.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. |
SimpleJdbcCall | A SimpleJdbcCall is a multi-threaded, reusable object representing a call to a stored procedure or a stored function. |
SimpleJdbcCallOperations | Interface specifying the API for a Simple JDBC Call implemented by SimpleJdbcCall . |
SimpleJdbcDaoSupport | Extension of JdbcDaoSupport
that exposes a SimpleJdbcTemplate as well. |
SimpleJdbcInsert | A SimpleJdbcInsert is a multi-threaded, reusable object providing easy insert capabilities for a table. |
SimpleJdbcInsertOperations | Interface specifying the API for a Simple JDBC Insert implemented by SimpleJdbcInsert . |
SimpleJdbcOperations | JDBC operations interface usable on Java 5 and above, exposing a set of common JDBC operations, whose interface is simplified through the use of varargs and autoboxing. |
SimpleJdbcTemplate | Java-5-based convenience wrapper for the classic Spring
JdbcTemplate ,
taking advantage of varargs and autoboxing, and exposing only the most
commonly required operations in order to simplify JdbcTemplate usage. |
SimpleJdbcTestUtils | A Java-5-based collection of JDBC related utility functions intended to simplify standard database testing scenarios. |
SimpleJndiBeanFactory | Simple JNDI-based implementation of Spring's
BeanFactory interface. |
SimpleLoadTimeWeaver | LoadTimeWeaver that builds and exposes a
SimpleInstrumentableClassLoader . |
SimpleLocaleContext | Simple implementation of the LocaleContext interface,
always returning a specified Locale . |
SimpleMailMessage | Models a simple mail message, including data such as the from, to, cc, subject, and text fields. |
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 DispatcherPortlet. |
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. |
SimpleMessageConverter | A simple message converter which is able to handle TextMessages, BytesMessages, MapMessages, and ObjectMessages. |
SimpleMessageConverter102 |
This class is deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based SimpleMessageConverter
|
SimpleMessageListenerContainer | Message listener container that uses the plain JMS client API's
MessageConsumer.setMessageListener() method to
create concurrent MessageConsumers for the specified listeners. |
SimpleMessageListenerContainer102 |
This class is deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based SimpleMessageListenerContainer
|
SimpleMetadataAwareAspectInstanceFactory | Implementation of MetadataAwareAspectInstanceFactory that
creates a new instance of the specified aspect class for every
getAspectInstance() call. |
SimpleMetadataReaderFactory | Simple implementation of the MetadataReaderFactory interface,
creating a new ASM org.springframework.asm.ClassReader for every request. |
SimpleNamespaceContext | Simple javax.xml.namespace.NamespaceContext implementation. |
SimpleNamingContext | Simple implementation of a JNDI naming context. |
SimpleNamingContextBuilder | Simple implementation of a JNDI naming context builder. |
SimpleNativeJdbcExtractor | Simple implementation of the NativeJdbcExtractor interface. |
SimplePortletHandlerAdapter | Adapter to use the Portlet interface with the generic DispatcherPortlet. |
SimplePortletPostProcessor | Bean post-processor that applies initialization and destruction callbacks to beans that implement the Portlet interface. |
SimpleProblemCollector | TODO SPR-7420: document |
SimplePropertyNamespaceHandler | Simple NamespaceHandler implementation that maps custom attributes
directly through to bean properties. |
SimpleRecordOperation | EIS operation object that accepts a passed-in CCI input Record and returns a corresponding CCI output Record. |
SimpleReflectiveMBeanInfoAssembler | Simple subclass of AbstractReflectiveMBeanInfoAssembler
that always votes yes for method and property inclusion, effectively exposing
all public methods and properties as operations and attributes. |
SimpleRemoteSlsbInvokerInterceptor | Basic invoker for a remote Stateless Session Bean. |
SimpleRemoteStatelessSessionProxyFactoryBean | Convenient FactoryBean for remote SLSB proxies. |
SimpleSaxErrorHandler | Simple org.xml.sax.ErrorHandler implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation. |
SimpleSecurityContextProvider | Simple SecurityContextProvider implementation. |
SimpleServletHandlerAdapter | Adapter to use the Servlet interface with the generic DispatcherServlet. |
SimpleServletPostProcessor | BeanPostProcessor
that applies initialization and destruction callbacks to beans that
implement the javax.servlet.Servlet interface. |
SimpleSessionStatus | Simple implementation of the SessionStatus interface,
keeping the complete flag as an instance variable. |
SimpleSpringBeanELResolver | Simple concrete variant of SpringBeanELResolver , delegating
to a given BeanFactory that the resolver was constructed with. |
SimpleSpringPreparerFactory | Tiles2 org.apache.tiles.preparer.PreparerFactory implementation that expects preparer class names and builds preparer instances for those, creating them through the Spring ApplicationContext in order to apply Spring container callbacks and configured Spring BeanPostProcessors. |
SimpleTaskWorkManager | Simple JCA 1.5 javax.resource.spi.work.WorkManager implementation that
delegates to a Spring TaskExecutor . |
SimpleTheme | Default Theme implementation, wrapping a name and an
underlying MessageSource . |
SimpleThreadPoolTaskExecutor | Subclass of Quartz's SimpleThreadPool that implements Spring's
TaskExecutor interface
and listens to Spring lifecycle callbacks. |
SimpleThreadScope | Thread-backed Scope implementation. |
SimpleThrowawayClassLoader | ClassLoader that can be used to load classes without bringing them into the parent loader. |
SimpleTraceInterceptor | Simple AOP Alliance MethodInterceptor that can be introduced
in a chain to display verbose trace information about intercepted method
invocations, with method entry and method exit info. |
SimpleTransactionFactory | Default implementation of the TransactionFactory strategy interface,
simply wrapping a standard JTA javax.transaction.TransactionManager. |
SimpleTransactionStatus | A simple TransactionStatus
implementation. |
SimpleTransformErrorListener | Simple javax.xml.transform.ErrorListener implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation. |
SimpleTriggerBean | Convenience subclass of Quartz's org.quartz.SimpleTrigger class, making bean-style usage easier. |
SimpleTriggerContext | Simple data holder implementation of the TriggerContext interface. |
SimpleTypeConverter | Simple implementation of the TypeConverter interface that does not operate on any specific target object. |
SimpleUrlHandlerMapping | Implementation of the HandlerMapping
interface to map from URLs to request handler beans. |
SingleColumnRowMapper<T> | RowMapper implementation that converts a single column into a single
result value per row. |
SingleConnectionDataSource | Implementation of SmartDataSource that wraps a single JDBC Connection
which is not closed after use. |
SingleConnectionFactory | A CCI ConnectionFactory adapter that returns the same Connection on all
getConnection calls, and ignores calls to
Connection.close() . |
SingleConnectionFactory | A JMS ConnectionFactory adapter that returns the same Connection
from all createConnection() calls, and ignores calls to
javax.jms.Connection#close(). |
SingleConnectionFactory102 |
This class is deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based SingleConnectionFactory
|
SingleDataSourceLookup | An implementation of the DataSourceLookup that simply wraps a single given DataSource, returned for any data source name. |
SingletonAspectInstanceFactory | Implementation of AspectInstanceFactory that is backed by a
specified singleton object, returning the same instance for every
getAspectInstance() call. |
SingletonBeanFactoryLocator | Keyed-singleton implementation of |
SingletonBeanRegistry | Interface that defines a registry for shared bean instances. |
SingletonMetadataAwareAspectInstanceFactory | Implementation of MetadataAwareAspectInstanceFactory that is backed
by a specified singleton object, returning the same instance for every
getAspectInstance() call. |
SingletonTargetSource | Implementation of the TargetSource interface
that holds a given object. |
SmartApplicationListener | Extended variant of the standard ApplicationListener interface,
exposing further metadata such as the supported event type. |
SmartClassLoader | Interface to be implemented by a reloading-aware ClassLoader (e.g. |
SmartConnectionFactory | Extension of the javax.jms.ConnectionFactory interface,
indicating how to release Connections obtained from it. |
SmartDataSource | Extension of the javax.sql.DataSource interface, to be
implemented by special DataSources that return JDBC Connections
in an unwrapped fashion. |
SmartFactoryBean<T> | Extension of the FactoryBean interface. |
SmartInstantiationAwareBeanPostProcessor | Extension of the InstantiationAwareBeanPostProcessor interface,
adding a callback for predicting the eventual type of a processed bean. |
SmartLifecycle | An extension of the Lifecycle interface for those objects that require to be started upon ApplicationContext refresh and/or shutdown in a particular order. |
SmartPersistenceUnitInfo | Extension of the standard JPA PersistenceUnitInfo interface, for advanced collaboration
between Spring's LocalEntityManagerFactoryBean and
PersistenceUnitManager implementations. |
SmartSessionBean | Interface to be implemented by Session Beans that want to expose important state to cooperating classes. |
SmartTransactionObject | Interface to be implemented by transaction objects that are able to return an internal rollback-only marker, typically from a another transaction that has participated and marked it as rollback-only. |
SoapFaultException | RemoteInvocationFailureException subclass that provides the details of a SOAP fault. |
SortDefinition | Definition for sorting bean instances by a property. |
SortedResourcesFactoryBean | FactoryBean implementation that takes a list of location Strings
and creates a sorted array of Resource instances. |
SourceAwareSpecification | TODO SPR-7420: document |
SourceExtractor | Simple strategy allowing tools to control how source metadata is attached to the bean definition metadata. |
SourceFilteringListener | ApplicationListener decorator that filters
events from a specified event source, invoking its delegate listener for
matching ApplicationEvent objects only. |
SourceHttpMessageConverter<T extends Source> | Implementation of HttpMessageConverter that can read and write Source objects. |
SpecificationContext | TODO: rename to SpecificationContext? |
SpelEvaluationException | Root exception for Spring EL related exceptions. |
SpelExpression | A SpelExpressions represents a parsed (valid) expression that is ready to be evaluated in a specified context. |
SpelExpressionParser | SpEL parser. |
SpelMessage | Contains all the messages that can be produced by the Spring Expression Language. |
SpelMessage.Kind | |
SpelNode | Represents a node in the Ast for a parsed expression. |
SpelNodeImpl | The common supertype of all AST nodes in a parsed Spring Expression Language format expression. |
SpelParseException | Root exception for Spring EL related exceptions. |
SpelParserConfiguration | Configuration object for the SpEL expression parser. |
SpringBeanAutowiringInterceptor | EJB3-compliant interceptor class that injects Spring beans into
fields and methods which are annotated with @Autowired . |
SpringBeanAutowiringSupport | Convenient base class for self-autowiring classes that gets constructed within a Spring-based web application. |
SpringBeanELResolver | Unified EL ELResolver that delegates to a Spring BeanFactory,
resolving name references to Spring-defined beans. |
SpringBeanFacesELResolver | JSF 1.2 ELResolver that delegates to the Spring root
WebApplicationContext , resolving name references to
Spring-defined beans. |
SpringBeanJobFactory | Subclass of AdaptableJobFactory that also supports Spring-style
dependency injection on bean properties. |
SpringBeanPreparerFactory | Tiles2 org.apache.tiles.preparer.PreparerFactory implementation that expects preparer bean names and obtains preparer beans from the Spring ApplicationContext. |
SpringBeanVariableResolver | This is a subclass of the JSF 1.1 DelegatingVariableResolver ,
letting Spring bean definitions override other attributes of the same name. |
SpringBindingActionForm | This class is deprecated. as of Spring 3.0 |
SpringCachingAnnotationParser | Strategy implementation for parsing Spring's Cacheable and CacheEvict annotations. |
SpringConstraintValidatorFactory | JSR-303 ConstraintValidatorFactory implementation that delegates to a Spring BeanFactory for creating autowired ConstraintValidator instances. |
SpringContextResourceAdapter | JCA 1.5 javax.resource.spi.ResourceAdapter implementation
that loads a Spring ApplicationContext ,
starting and stopping Spring-managed beans as part of the ResourceAdapter's
lifecycle. |
SpringFailOnTimeout | SpringFailOnTimeout is a custom JUnit 4.5+ Statement
which adds support for Spring's @Timed annotation by throwing
an exception if the next statement in the execution chain takes more than the
specified number of milliseconds. |
SpringJtaSynchronizationAdapter | Adapter that implements the JTA javax.transaction.Synchronization
interface delegating to an underlying Spring
TransactionSynchronization . |
SpringJUnit4ClassRunner |
|
SpringLobCreatorSynchronization | Callback for resource cleanup at the end of a Spring transaction. |
SpringLocaleResolver | Tiles LocaleResolver adapter that delegates to a Spring
LocaleResolver ,
exposing the DispatcherServlet-managed locale. |
SpringModelMBean | Extension of the RequiredModelMBean class that ensures the
thread context ClassLoader is switched
for the managed resource's ClassLoader before any invocations occur. |
SpringPersistenceManagerProxyBean | Proxy that implements the javax.jdo.PersistenceManager interface, delegating to the current thread-bound PersistenceManager (the Spring-managed transactional PersistenceManager or the single OpenPersistenceManagerInView PersistenceManager, if any) on each invocation. |
SpringProxy | Marker interface implemented by all AOP proxies. |
SpringRepeat | SpringRepeat is a custom JUnit 4.5+ Statement which adds
support for Spring's @Repeat annotation by repeating the
test for the specified number of times. |
SpringResourceLoader | Velocity ResourceLoader adapter that loads via a Spring ResourceLoader. |
SpringSessionContext | Implementation of Hibernate 3.1's CurrentSessionContext interface that delegates to Spring's SessionFactoryUtils for providing a Spring-managed current Session. |
SpringTemplateLoader | FreeMarker TemplateLoader adapter that loads via a Spring ResourceLoader. |
SpringTilesApplicationContextFactory | Spring-specific subclass of the standard Tiles AbstractTilesApplicationContextFactory, passing given properties through as Tiles init-param map. |
SpringTransactionAnnotationParser | Strategy implementation for parsing Spring's Transactional annotation. |
SpringTransactionFactory | Spring-aware implementation of the Hibernate TransactionFactory interface, aware of Spring-synchronized transactions (in particular Spring-managed JTA transactions) and asking for default release mode ON_CLOSE. |
SpringValidatorAdapter | Adapter that takes a JSR-303 javax.validator.Validator
and exposes it as a Spring Validator
while also exposing the original JSR-303 Validator interface itself. |
SpringVersion | Class that exposes the Spring version. |
SqlCall | RdbmsOperation using a JdbcTemplate and representing a SQL-based call such as a stored procedure or a stored function. |
SQLErrorCodes | JavaBean for holding JDBC error codes for a particular database. |
SQLErrorCodesFactory | Factory for creating SQLErrorCodes based on the
"databaseProductName" taken from the java.sql.DatabaseMetaData. |
SQLErrorCodeSQLExceptionTranslator | Implementation of SQLExceptionTranslator that analyzes vendor-specific error codes. |
SQLExceptionSubclassTranslator | SQLExceptionTranslator implementation which analyzes the specific
java.sql.SQLException subclass thrown by the JDBC driver. |
SQLExceptionTranslator | Strategy interface for translating between SQLException SQLExceptions
and Spring's data access strategy-agnostic DataAccessException
hierarchy. |
SqlFunction<T> | SQL "function" wrapper for a query that returns a single row of results. |
SqlInOutParameter | Subclass of SqlOutParameter to represent an INOUT parameter. |
SqlLobValue | Object to represent an SQL BLOB/CLOB value parameter. |
SqlMapClientCallback<T> | Callback interface for data access code that works with the iBATIS com.ibatis.sqlmap.client.SqlMapExecutor interface. |
SqlMapClientDaoSupport | Convenient super class for iBATIS SqlMapClient data access objects. |
SqlMapClientFactoryBean | FactoryBean that creates an
iBATIS com.ibatis.sqlmap.client.SqlMapClient. |
SqlMapClientOperations | Interface that specifies a basic set of iBATIS SqlMapClient operations,
implemented by SqlMapClientTemplate . |
SqlMapClientTemplate | Helper class that simplifies data access via the iBATIS
com.ibatis.sqlmap.client.SqlMapClient API, converting checked
SQLExceptions into unchecked DataAccessExceptions, following the
org.springframework.dao exception hierarchy. |
SqlOperation | Operation object representing a SQL-based operation such as a query or update, as opposed to a stored procedure. |
SqlOutParameter | Subclass of SqlParameter to represent an output parameter. |
SqlParameter | Object to represent a SQL parameter definition. |
SqlParameterSource | Interface that defines common functionality for objects that can
offer parameter values for named SQL parameters, serving as argument
for NamedParameterJdbcTemplate operations. |
SqlParameterSourceUtils | Class that provides helper methods for the use of SqlParameterSource
with SimpleJdbc classes. |
SqlParameterValue | Object to represent a SQL parameter value, including parameter metadata such as the SQL type and the scale for numeric values. |
SqlProvider | Interface to be implemented by objects that can provide SQL strings. |
SqlQuery<T> | Reusable operation object representing a SQL query. |
SqlReturnResultSet | Represents a returned java.sql.ResultSet from a stored procedure call. |
SqlReturnType | Interface to be implemented for retrieving values for more complex database-specific
types not supported by the standard CallableStatement.getObject method. |
SqlReturnUpdateCount | Represents a returned update count from a stored procedure call. |
SqlRowSet | Mirror interface for javax.sql.RowSet , representing
disconnected java.sql.ResultSet data. |
SqlRowSetMetaData | Meta data interface for Spring's SqlRowSet,
analogous to javax.sql.ResultSetMetaData
The main difference to the standard JDBC RowSetMetaData is that an SQLException is never thrown here. |
SqlRowSetResultSetExtractor | ResultSetExtractor implementation that returns a Spring SqlRowSet representation for each given ResultSet. |
SqlServerCallMetaDataProvider | SQL Server specific implementation for the CallMetaDataProvider interface. |
SqlServerMaxValueIncrementer | DataFieldMaxValueIncrementer that increments the maximum value of a given SQL Server table
with the equivalent of an auto-increment column. |
SQLStateSQLExceptionTranslator | SQLExceptionTranslator implementation that analyzes the SQL state in
the SQLException based on the first two digits (the SQL state "class"). |
SqlTypeValue | Interface to be implemented for setting values for more complex database-specific
types not supported by the standard setObject method. |
SqlUpdate | Reusable operation object representing a SQL update. |
SqlValue | Simple interface for complex types to be set as statement parameters. |
SQLWarningException | Exception thrown when we're not ignoring java.sql.SQLWarning SQLWarnings. |
SqlXmlFeatureNotImplementedException | Exception thrown when the underlying implementation does not support the requested feature of the API. |
SqlXmlHandler | Abstraction for handling XML fields in specific databases. |
SqlXmlObjectMappingHandler | Abstraction for handling XML object mapping to fields in a database. |
SqlXmlValue | Subinterface of SqlValue
that supports passing in XML data to specified column and adds a
cleanup callback, to be invoked after the value has been set and
the corresponding statement has been executed. |
StandardAnnotationMetadata | AnnotationMetadata implementation that uses standard reflection
to introspect a given Class . |
StandardBeanExpressionResolver | Standard implementation of the
BeanExpressionResolver
interface, parsing and evaluating Spring EL using Spring's expression module. |
StandardClassMetadata | ClassMetadata implementation that uses standard reflection
to introspect a given Class . |
StandardEvaluationContext | Provides a default EvaluationContext implementation. |
StandardJmsActivationSpecFactory | Standard implementation of the JmsActivationSpecFactory interface. |
StandardMethodMetadata | MethodMetadata implementation that uses standard reflection
to introspect a given Method . |
StandardOperatorOverloader | |
StandardPersistenceManagerProxyBean | Proxy that implements the javax.jdo.PersistenceManager interface, delegating to a thread-bound PersistenceManager on each invocation - as defined by the JDO 2.1 specification. |
StandardTypeComparator | A simple basic TypeComparator implementation. |
StandardTypeConverter | Default implementation of the TypeConverter interface,
delegating to a core Spring ConversionService . |
StandardTypeLocator | A default implementation of a TypeLocator that uses the context classloader (or any classloader set upon it). |
StatementCallback<T> | Generic callback interface for code that operates on a JDBC Statement. |
StatementCreatorUtils | Utility methods for PreparedStatementSetter/Creator and CallableStatementCreator implementations, providing sophisticated parameter management (including support for LOB values). |
StaticApplicationContext | ApplicationContext implementation
which supports programmatic registration of beans and messages,
rather than reading bean definitions from external configuration sources. |
StaticLabeledEnum | This class is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
StaticLabeledEnumResolver | This class is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
StaticListableBeanFactory | Static BeanFactory implementation
which allows to register existing singleton instances programmatically. |
StaticMessageSource | Simple implementation of MessageSource
which allows messages to be registered programmatically. |
StaticMethodMatcher | Convenient abstract superclass for static method matchers, which don't care about arguments at runtime. |
StaticMethodMatcherPointcut | Convenient superclass when we want to force subclasses to implement the
MethodMatcher interface but subclasses will want to be pointcuts. |
StaticMethodMatcherPointcutAdvisor | Convenient base class for Advisors that are also static pointcuts. |
StaticPortletApplicationContext | Static Portlet-based ApplicationContext
implementation for testing. |
StaticScriptSource | Static implementation of the
ScriptSource interface,
encapsulating a given String that contains the script source text. |
StaticWebApplicationContext | Static WebApplicationContext
implementation for testing. |
StaxUtils | Convenience methods for working with the StAX API. |
StopWatch | Simple stop watch, allowing for timing of a number of tasks, exposing total running time and running time for each named task. |
StopWatch.TaskInfo | Inner class to hold data about one task executed within the stop watch. |
StoredProcedure | Superclass for object abstractions of RDBMS stored procedures. |
StreamingSimpleClientHttpRequest | ClientHttpRequest implementation that uses standard J2SE facilities to execute streaming requests. |
StringArrayPropertyEditor | Custom java.beans.PropertyEditor for String arrays. |
StringCodedLabeledEnum | This class is deprecated. as of Spring 3.0, in favor of Java 5 enums. |
StringHttpMessageConverter | Implementation of HttpMessageConverter that can read and write strings. |
StringLiteral | |
StringMultipartFileEditor | Custom java.beans.PropertyEditor for converting
MultipartFiles to Strings. |
StringTrimmerEditor | Property editor that trims Strings. |
StringUtils | Miscellaneous String utility methods. |
StringValueResolver | Simple strategy interface for resolving a String value. |
StylerUtils | Simple utility class to allow for convenient access to value styling logic, mainly to support descriptive logging messages. |
SubscriptionNameProvider | Interface to be implemented by message listener objects that suggest a specific name for a durable subscription that they might be registered with. |
SybaseAnywhereMaxValueIncrementer | DataFieldMaxValueIncrementer that increments
the maximum value of a given Sybase SQL Anywhere table
with the equivalent of an auto-increment column. |
SybaseCallMetaDataProvider | Sybase specific implementation for the CallMetaDataProvider interface. |
SybaseMaxValueIncrementer | DataFieldMaxValueIncrementer that increments
the maximum value of a given Sybase SQL Server table
with the equivalent of an auto-increment column. |
SynchedLocalTransactionFailedException | Exception thrown when a synchronized local transaction failed to complete (after the main transaction has already completed). |
SyncTaskExecutor | TaskExecutor implementation that executes each task synchronously
in the calling thread. |
SystemProfileValueSource | Implementation of ProfileValueSource which uses system properties as
the underlying source. |
SystemPropertyUtils | Helper class for resolving placeholders in texts. |
TableMetaDataContext | Class to manage context metadata used for the configuration and execution of operations on a database table. |
TableMetaDataProvider | Interface specifying the API to be implemented by a class providing table metedata. |
TableMetaDataProviderFactory | Factory used to create a TableMetaDataProvider implementation based on the type of databse being used. |
TableParameterMetaData | Holder of metadata for a specific parameter that is used for table processing. |
TagUtils | Utility class for tag library related code, exposing functionality such as translating String Strings to web scopes. |
TagWriter | Utility class for writing HTML content to a Writer instance. |
TargetClassAware | Minimal interface for exposing the target class behind a proxy. |
TargetSource | A TargetSource is used to obtain the current "target" of
an AOP invocation, which will be invoked via reflection if no around
advice chooses to end the interceptor chain itself. |
TargetSourceCreator | Implementations can create special target sources, such as pooling target sources, for particular beans. |
TaskExecutor | Simple task executor interface that abstracts the execution of a Runnable. |
TaskExecutorAdapter | Adapter that takes a JDK 1.5 java.util.concurrent.Executor and
exposes a Spring TaskExecutor for it. |
TaskExecutorFactoryBean | FactoryBean for creating ThreadPoolTaskExecutor instances, choosing between the standard concurrent and the backport-concurrent variant. |
TaskNamespaceHandler | NamespaceHandler for the 'task' namespace. |
TaskRejectedException | Exception thrown when a TaskExecutor rejects to accept
a given task for execution. |
TaskScheduler | Task scheduler interface that abstracts the scheduling of Runnable Runnables based on different kinds of triggers. |
TaskTimeoutException | Exception thrown when a AsyncTaskExecutor rejects to accept
a given task for execution because of the specified timeout. |
TaskUtils | Utility methods for decorating tasks with error handling. |
TemplateAwareExpressionParser | An expression parser that understands templates. |
TemplateParserContext | Configurable ParserContext implementation for template parsing. |
Ternary | Represents a ternary expression, for example: "someCheck()?true:false". |
TestContext | TestContext encapsulates the context in which a test is executed, agnostic of the actual testing framework in use. |
TestContextManager |
|
TestExecutionListener |
|
TestExecutionListeners | TestExecutionListeners defines class-level metadata for
configuring which TestExecutionListeners should
be registered with a TestContextManager . |
TextareaTag | Databinding-aware JSP tag for rendering an HTML 'textarea '. |
Theme | A Theme can resolve theme-specific messages, codes, file paths, etcetera (e.g. CSS and image files in a web environment). |
ThemeChangeInterceptor | Interceptor that allows for changing the current theme on every request, via a configurable request parameter. |
ThemeResolver | Interface for web-based theme resolution strategies that allows for both theme resolution via the request and theme modification via request and response. |
ThemeSource | Interface to be implemented by objects that can resolve Themes . |
ThemeTag | Custom tag to look up a theme message in the scope of this page. |
ThreadLocalTargetSource | Alternative to an object pool. |
ThreadLocalTargetSourceStats | Statistics for a ThreadLocal TargetSource. |
ThreadPoolExecutorFactoryBean | JavaBean that allows for configuring a JDK 1.5 java.util.concurrent.ThreadPoolExecutor in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its native java.util.concurrent.ExecutorService type. |
ThreadPoolTaskExecutor | JavaBean that allows for configuring a JSR-166 backport
edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor in bean
style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
properties), exposing it as a Spring TaskExecutor . |
ThreadPoolTaskExecutor | JavaBean that allows for configuring a JDK 1.5 java.util.concurrent.ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
properties) and exposing it as a Spring TaskExecutor . |
ThreadPoolTaskScheduler | Implementation of Spring's TaskScheduler interface, wrapping
a native java.util.concurrent.ScheduledThreadPoolExecutor. |
ThrowsAdvice | Tag interface for throws advice. |
ThrowsAdviceInterceptor | Interceptor to wrap an after-throwing advice. |
TilesConfigurer | This class is deprecated. as of Spring 3.0 |
TilesConfigurer | Helper class to configure Tiles 2.x for the Spring Framework. |
TilesJstlView | This class is deprecated. as of Spring 3.0 |
TilesView | This class is deprecated. as of Spring 3.0 |
TilesView | View implementation that retrieves a
Tiles definition. |
TilesViewResolver | Convenience subclass of UrlBasedViewResolver
that supports TilesView (i.e. |
Timed | Test-specific annotation to indicate that a test method has to finish execution in a #millis() specified time period. |
TimerFactoryBean |
This class is deprecated.
as of Spring 3.0, in favor of the scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService
|
TimerManagerAccessor | Base class for classes that are accessing a CommonJ commonj.timers.TimerManager Defines common configuration settings and common lifecycle handling. |
TimerManagerFactoryBean | FactoryBean that retrieves a
CommonJ commonj.timers.TimerManager and exposes it for bean references. |
TimerManagerTaskScheduler | Implementation of Spring's TaskScheduler interface, wrapping
a CommonJ commonj.timers.TimerManager. |
TimerTaskExecutor |
This class is deprecated.
as of Spring 3.0, in favor of the scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService
|
TimeZoneEditor | Editor for java.util.TimeZone , translating timezone IDs into
TimeZone objects. |
TomcatInstrumentableClassLoader | Extension of Tomcat's default class loader which adds instrumentation to loaded classes without the need to use a VM-wide agent. |
TopLinkJpaDialect | JpaDialect implementation for
Oracle TopLink Essentials. |
TopLinkJpaVendorAdapter | JpaVendorAdapter implementation for
Oracle TopLink Essentials. |
ToStringCreator | Utility class that builds pretty-printing toString() methods
with pluggable styling conventions. |
ToStringStyler | A strategy interface for pretty-printing toString() methods. |
Transactional | Describes transaction attributes on a method or class. |
TransactionalTestExecutionListener |
|
TransactionAnnotationParser | Strategy interface for parsing known transaction annotation types. |
TransactionAspectSupport | Base class for transactional aspects, such as the TransactionInterceptor
or an AspectJ aspect. |
TransactionAspectSupport.TransactionInfo | Opaque object used to hold Transaction information. |
TransactionAspectUtils | Utility methods for obtaining a PlatformTransactionManager by
qualifier value . |
TransactionAttribute | This interface adds a rollbackOn specification to TransactionDefinition . |
TransactionAttributeEditor | PropertyEditor for TransactionAttribute objects. |
TransactionAttributeSource | Interface used by TransactionInterceptor. |
TransactionAttributeSourceAdvisor | Advisor driven by a TransactionAttributeSource , used to include
a TransactionInterceptor only for methods that are transactional. |
TransactionAttributeSourceEditor | Property editor that converts a String into a TransactionAttributeSource . |
TransactionAwareConnectionFactoryProxy | Proxy for a target CCI javax.resource.cci.ConnectionFactory, adding awareness of Spring-managed transactions. |
TransactionAwareConnectionFactoryProxy | Proxy for a target JMS javax.jms.ConnectionFactory, adding awareness of Spring-managed transactions. |
TransactionAwareDataSourceConnectionProvider | Subclass of LocalDataSourceConnectionProvider that returns a transaction-aware proxy for the exposed DataSource. |
TransactionAwareDataSourceProxy | Proxy for a target JDBC javax.sql.DataSource, adding awareness of Spring-managed transactions. |
TransactionAwarePersistenceManagerFactoryProxy | Proxy for a target JDO javax.jdo.PersistenceManagerFactory,
returning the current thread-bound PersistenceManager (the Spring-managed
transactional PersistenceManager or the single OpenPersistenceManagerInView
PersistenceManager) on getPersistenceManager() , if any. |
TransactionCallback<T> | Callback interface for transactional code. |
TransactionCallbackWithoutResult | Simple convenience class for TransactionCallback implementation. |
TransactionConfiguration | TransactionConfiguration defines class-level metadata for configuring transactional tests. |
TransactionConfigurationAttributes | Configuration attributes for configuring transactional tests. |
TransactionDefinition | Interface that defines Spring-compliant transaction properties. |
TransactionException | Superclass for all transaction exceptions. |
TransactionFactory | Strategy interface for creating JTA javax.transaction.Transaction objects based on specified transactional characteristics. |
TransactionInProgressException | Runtime exception mirroring the JMS TransactionInProgressException. |
TransactionInterceptor | AOP Alliance MethodInterceptor for declarative transaction
management using the common Spring transaction infrastructure
(PlatformTransactionManager ). |
TransactionOperations | Interface specifying basic transaction execution operations. |
TransactionProxyFactoryBean | Proxy factory bean for simplified declarative transaction handling. |
TransactionRolledBackException | Runtime exception mirroring the JMS TransactionRolledBackException. |
TransactionStatus | Representation of the status of a transaction. |
TransactionSuspensionNotSupportedException | Exception thrown when attempting to suspend an existing transaction but transaction suspension is not supported by the underlying backend. |
TransactionSynchronization | Interface for transaction synchronization callbacks. |
TransactionSynchronizationAdapter | Simple TransactionSynchronization adapter containing empty
method implementations, for easier overriding of single methods. |
TransactionSynchronizationManager | Central helper that manages resources and transaction synchronizations per thread. |
TransactionSynchronizationUtils | Utility methods for triggering specific TransactionSynchronization
callback methods on all currently registered synchronizations. |
TransactionSystemException | Exception thrown when a general transaction system error is encountered, like on commit or rollback. |
TransactionTemplate | Template class that simplifies programmatic transaction demarcation and transaction exception handling. |
TransactionTimedOutException | Exception to be thrown when a transaction has timed out. |
TransactionUsageException | Superclass for exceptions caused by inappropriate usage of a Spring transaction API. |
TransformerUtils | Contains common behavior relating to javax.xml.transform.Transformer Transformers, and the
javax.xml.transform package in general. |
TransformTag | Tag for transforming reference data values from form controllers and
other objects inside a spring:bind tag (or a data-bound
form element tag from Spring's form tag library). |
TransientDataAccessException | Root of the hierarchy of data access exceptions that are considered transient - where a previously failed operation might be able to succeed when the operation is retried without any intervention by application-level functionality. |
TransientDataAccessResourceException | Data access exception thrown when a resource fails temporarily and the operation can be retried. |
Trigger | Common interface for trigger objects that determine the next execution time of a task that they get associated with. |
TriggerContext | Context object encapsulating last execution times and last completion time of a given task. |
TxAnnotationDriven | TODO SPR-7420: document |
TxNamespaceHandler | NamespaceHandler allowing for the configuration of
declarative transaction management using either XML or using annotations. |
TypeCode | Captures primitive types and their corresponding class objects, plus one special entry that represents all reference (non-primitive) types. |
TypeComparator | Instances of a type comparator should be able to compare pairs of objects for equality, the specification of the return value is the same as for Comparable. |
TypeConverter | Interface that defines type conversion methods. |
TypeConverter | A type converter can convert values between different types encountered during expression evaluation. |
TypeDefinitionBean | Bean that encapsulates a Hibernate type definition. |
TypeDescriptor | Context about a type to convert to. |
TypedStringValue | Holder for a typed String value. |
TypedValue | Encapsulates an object and a type descriptor that describes it. |
TypeFilter | Base interface for type filters using a
MetadataReader . |
TypeLocator | Implementors of this interface are expected to be able to locate types. |
TypeMismatchDataAccessException | Exception thrown on mismatch between Java type and database type: for example on an attempt to set an object of the wrong type in an RDBMS column. |
TypeMismatchException | Exception thrown on a type mismatch when trying to set a bean property. |
TypeMismatchNamingException | Exception thrown if a type mismatch is encountered for an object located in a JNDI environment. |
TypePatternClassFilter | Spring AOP ClassFilter implementation using AspectJ type matching. |
TypeReference | Represents a reference to a type, for example "T(String)" or "T(com.somewhere.Foo)" |
TypeUtils | Utility to work with Java 5 generic type parameters. |
UiApplicationContextUtils | Utility class for UI application context implementations. |
UnableToRegisterMBeanException | Exception thrown when we are unable to register an MBean, for example because of a naming conflict. |
UnableToSendNotificationException | Thrown when a JMX javax.management.Notification is unable to be sent. |
UncategorizedDataAccessException | Normal superclass when we can't distinguish anything more specific than "something went wrong with the underlying resource": for example, a SQLException from JDBC we can't pinpoint more precisely. |
UncategorizedJmsException | JmsException to be thrown when no other matching subclass found. |
UncategorizedMappingException | Exception that indicates that the cause cannot be distinguished further. |
UncategorizedSQLException | Exception thrown when we can't classify a SQLException into one of our generic data access exceptions. |
UnexpectedRollbackException | Thrown when an attempt to commit a transaction resulted in an unexpected rollback. |
UnknownAdviceTypeException | Exception thrown when an attempt is made to use an unsupported Advisor or Advice type. |
Unmarshaller | Defines the contract for Object XML Mapping unmarshallers. |
UnmarshallingFailureException | Exception thrown on unmarshalling failure. |
UnsatisfiedDependencyException | Exception thrown when a bean depends on other beans or simple properties that were not specified in the bean factory definition, although dependency checking was enabled. |
UnsatisfiedServletRequestParameterException | ServletRequestBindingException subclass that indicates an unsatisfied
parameter condition, as typically expressed using an @RequestMapping
annotation at the @Controller type level. |
UpdatableSqlQuery<T> | Reusable RDBMS query in which concrete subclasses must implement the abstract updateRow(ResultSet, int, context) method to update each row of the JDBC ResultSet and optionally map contents into an object. |
UpdatableSqlQuery.RowMapperImpl | Implementation of RowMapper that calls the enclosing
class's updateRow() method for each row. |
URIEditor | Editor for java.net.URI , to directly populate a URI property
instead of using a String property as bridge. |
UriTemplate | Represents a URI template. |
UriUtils | Utility class for URI encoding and decoding based on RFC 3986. |
UrlBasedRemoteAccessor | Abstract base class for classes that access remote services via URLs. |
UrlBasedViewResolver | Simple implementation of the ViewResolver
interface, allowing for direct resolution of symbolic view names to URLs,
without explicit mapping definition. |
URLEditor | Editor for java.net.URL , to directly populate a URL property
instead of using a String property as bridge. |
UrlFilenameViewController | Simple Controller implementation that transforms the virtual
path of a URL into a view name and returns that view. |
UrlPathHelper | Helper class for URL path matching. |
UrlResource | Resource implementation for java.net.URL locators. |
UrlTag | JSP tag for creating URLs. |
UserCredentialsConnectionFactoryAdapter | An adapter for a target JMS javax.jms.ConnectionFactory, applying the
given user credentials to every standard createConnection() call,
that is, implicitly invoking createConnection(username, password)
on the target. |
UserCredentialsDataSourceAdapter | An adapter for a target JDBC javax.sql.DataSource, applying the specified
user credentials to every standard getConnection() call, implicitly
invoking getConnection(username, password) on the target. |
UserRoleAuthorizationInterceptor | Interceptor that checks the authorization of the current user via the user's roles, as evaluated by PortletRequest's isUserInRole method. |
UserRoleAuthorizationInterceptor | Interceptor that checks the authorization of the current user via the user's roles, as evaluated by HttpServletRequest's isUserInRole method. |
UserTransactionAdapter | Adapter for a JTA UserTransaction handle, taking a JTA javax.transaction.TransactionManager reference and creating a JTA javax.transaction.UserTransaction handle for it. |
UtilNamespaceHandler | NamespaceHandler for the util namespace. |
UUIDEditor | Editor for java.util.UUID , translating UUID
String representations into UUID objects and back. |
ValidationFailureException | Exception thrown on marshalling validation failure. |
ValidationUtils | Utility class offering convenient methods for invoking a Validator
and for rejecting empty fields. |
Validator | A validator for application-specific objects. |
Value | Annotation at the field or method/constructor parameter level that indicates a default value expression for the affected argument. |
ValueConstants | Common value constants shared between bind annotations. |
ValueStyler | Strategy that encapsulates value String styling algorithms according to Spring conventions. |
VariableReference | Represents a variable reference, eg. |
VelocityConfig | Interface to be implemented by objects that configure and manage a VelocityEngine for automatic lookup in a web environment. |
VelocityConfigurer | JavaBean to configure Velocity for web usage, via the "configLocation" and/or "velocityProperties" and/or "resourceLoaderPath" bean properties. |
VelocityEngineFactory | Factory that configures a VelocityEngine. |
VelocityEngineFactoryBean | Factory bean that configures a VelocityEngine and provides it as bean reference. |
VelocityEngineUtils | Utility class for working with a VelocityEngine. |
VelocityLayoutView | VelocityLayoutView emulates the functionality offered by Velocity's VelocityLayoutServlet to ease page composition from different templates. |
VelocityLayoutViewResolver | Convenience subclass of VelocityViewResolver, adding support for VelocityLayoutView and its properties. |
VelocityToolboxView | VelocityView subclass which adds support for Velocity Tools toolboxes
and Velocity Tools ViewTool callbacks / Velocity Tools 1.3 init methods. |
VelocityView | View using the Velocity template engine. |
VelocityViewResolver | Convenience subclass of UrlBasedViewResolver
that supports VelocityView (i.e. |
VfsResource | VFS based Resource implementation. |
VfsUtils | Utility for detecting the JBoss VFS version available in the classpath. |
View | MVC View for a web interaction. |
ViewRendererServlet | ViewRendererServlet is a bridge servlet, mainly for the Portlet MVC support. |
ViewResolver | Interface to be implemented by objects that can resolve views by name. |
WeakReferenceMonitor | Track references to arbitrary objects using proxy and weak references. |
WeakReferenceMonitor.ReleaseListener | Listener that is notified when the handle is being released. |
WeavingTransformer | ClassFileTransformer-based weaver, allowing for a list of transformers to be applied on a class byte array. |
WebApplicationContext | Interface to provide configuration for a web application. |
WebApplicationContextFacesELResolver | Special JSF 1.2 ELResolver that exposes the Spring
WebApplicationContext instance under a variable named
"webApplicationContext". |
WebApplicationContextUtils | Convenience methods for retrieving the root
WebApplicationContext for a given
ServletContext . |
WebApplicationContextVariableResolver | Special JSF 1.1 VariableResolver that exposes the Spring
WebApplicationContext instance under a variable named
"webApplicationContext". |
WebApplicationObjectSupport | Convenient superclass for application objects running in a WebApplicationContext. |
WebAppRootListener | Listener that sets a system property to the web application root directory. |
WebArgumentResolver | SPI for resolving custom arguments for a specific handler method parameter. |
WebBindingInitializer | Callback interface for initializing a WebDataBinder
for performing data binding in the context of a specific web request. |
WebContentGenerator | Convenient superclass for any kind of web content generator,
like AbstractController
and WebContentInterceptor . |
WebContentInterceptor | Interceptor that checks and prepares request and response. |
WebDataBinder | Special DataBinder for data binding from web request parameters
to JavaBean objects. |
WebLogicJtaTransactionManager | Special JtaTransactionManager variant for BEA WebLogic (9.0 and higher). |
WebLogicLoadTimeWeaver | LoadTimeWeaver implementation for WebLogic's instrumentable
ClassLoader. |
WebLogicNativeJdbcExtractor | Implementation of the NativeJdbcExtractor interface for WebLogic,
supporting WebLogic Server 8.1 and higher. |
WebRequest | Generic interface for a web request. |
WebRequestDataBinder | Special DataBinder to perform data binding
from web request parameters to JavaBeans, including support for multipart files. |
WebRequestHandlerInterceptorAdapter | Adapter that implements the Portlet HandlerInterceptor interface and wraps an underlying WebRequestInterceptor. |
WebRequestHandlerInterceptorAdapter | Adapter that implements the Servlet HandlerInterceptor interface and wraps an underlying WebRequestInterceptor. |
WebRequestInterceptor | Interface for general web request interception. |
WebSphereDataSourceAdapter | DataSource implementation that delegates all calls to a WebSphere target DataSource, typically obtained from JNDI, applying a current isolation level and/or current user credentials to every Connection obtained from it. |
WebSphereLoadTimeWeaver | LoadTimeWeaver implementation for WebSphere instrumentable classloader. |
WebSphereMBeanServerFactoryBean | FactoryBean that obtains a WebSphere javax.management.MBeanServer
reference through WebSphere's proprietary AdminServiceFactory API,
available on WebSphere 5.1 and higher. |
WebSphereNativeJdbcExtractor | Implementation of the NativeJdbcExtractor interface for WebSphere,
supporting WebSphere Application Server 5.1 and higher. |
WebSphereUowTransactionManager | WebSphere-specific PlatformTransactionManager implementation that delegates to a com.ibm.wsspi.uow.UOWManager instance, obtained from WebSphere's JNDI environment. |
WebUtils | Miscellaneous utilities for web applications. |
WorkManagerTaskExecutor | TaskExecutor implementation
that delegates to a JCA 1.5 WorkManager, implementing the
javax.resource.spi.work.WorkManager interface. |
WorkManagerTaskExecutor | TaskExecutor implementation that delegates to a CommonJ WorkManager, implementing the commonj.work.WorkManager interface, which either needs to be specified as reference or through the JNDI name. |
XmlAwareFormHttpMessageConverter | Extension of FormHttpMessageConverter ,
adding support for XML-based parts through a SourceHttpMessageConverter . |
XmlBeanDefinitionReader | Bean definition reader for XML bean definitions. |
XmlBeanDefinitionStoreException | XML-specific BeanDefinitionStoreException subclass that wraps a org.xml.sax.SAXException, typically a org.xml.sax.SAXParseException which contains information about the error location. |
XmlBeanFactory |
This class is deprecated.
as of Spring 3.1 in favor of DefaultListableBeanFactory and
XmlBeanDefinitionReader
|
XmlBeansMarshaller | Implementation of the Marshaller interface for Apache XMLBeans. |
XmlBinaryStreamProvider | Interface defining handling involved with providing OutputStream
data for XML input. |
XmlCharacterStreamProvider | Interface defining handling involved with providing Writer
data for XML input. |
XmlMappingException | Root of the hierarchy of Object XML Mapping exceptions. |
XmlOptionsFactoryBean | FactoryBean that configures an XMLBeans XmlOptions object
and provides it as a bean reference. |
XmlPortletApplicationContext | Portlet-based WebApplicationContext
implementation which takes its configuration from XML documents, understood
by an XmlBeanDefinitionReader . |
XmlReaderContext | Extension of ReaderContext ,
specific to use with an XmlBeanDefinitionReader . |
XmlResultProvider | Interface defining handling involved with providing Result
data for XML input. |
XmlValidationModeDetector | Detects whether an XML stream is using DTD- or XSD-based validation. |
XmlViewResolver | Implementation of ViewResolver that uses bean definitions in an XML file, specified by resource location. |
XmlWebApplicationContext | WebApplicationContext implementation
which takes its configuration from XML documents, understood by an
XmlBeanDefinitionReader . |
XsltView | XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation. |
XsltViewResolver | ViewResolver implementation that
resolves instances of XsltView by translating the supplied view name
into the URL of the XSLT stylesheet. |
XStreamMarshaller | Implementation of the Marshaller interface for XStream. |