Class Index

A B C D E F G H I J K L M N O P Q R S T U V W X

A

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 ApplicationContext testing support in a JUnit 3.8 environment. 

AbstractJUnit4SpringContextTests

Abstract base test class which integrates the Spring TestContext Framework with explicit ApplicationContext testing support in a JUnit 4.5+ environment. 

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 Filters 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 ApplicationContext testing support in a TestNG environment. 

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 transactional extension of AbstractJUnit38SpringContextTests which adds convenience functionality for JDBC access. 

AbstractTransactionalJUnit4SpringContextTests

Abstract transactional extension of AbstractJUnit4SpringContextTests which adds convenience functionality for JDBC access. 

AbstractTransactionalSpringContextTests This class is deprecated. as of Spring 3.0, in favor of using the listener-based test context framework (AbstractJUnit38SpringContextTests)  
AbstractTransactionalTestNGSpringContextTests

Abstract transactional extension of AbstractTestNGSpringContextTests which adds convenience functionality for JDBC access. 

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 public void method should be executed after a transaction is ended for test methods configured to run within a transaction via the @Transactional annotation. 

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. 

B

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 public void method should be executed before a transaction is started for test methods configured to run within a transaction via the @Transactional annotation. 

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. 

C

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 Caches. 
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, translating charset String representations into Charset objects and back. 
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 SingletonBeanFactoryLocator which creates its internal bean factory reference as an ApplicationContext instead of SingletonBeanFactoryLocator's simple BeanFactory. 

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. 

D

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:
  • after the current test, when declared at the method level
  • after each test method in the current test class, when declared at the class level with class mode set to AFTER_EACH_TEST_METHOD
  • after the current test class, when declared at the class level with class mode set to AFTER_CLASS

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. 

E

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. 

F

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)". 

G

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 AbstractGenericContextLoader which reads bean definitions from Java Properties resources. 

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. 

H

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

I

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 ClientHttpRequestInterceptors. 
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. 

J

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. 

K

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

L

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. 

M

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. 

N

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. 

O

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:
  • subtraction of doubles (floats are represented as doubles)
  • subtraction of longs
  • subtraction of integers
  • subtraction of an int from a string of one character (effectively decreasing that character), so 'd'-3='a'
It can be used as a unary operator for numbers (double/long/int). 
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:
  • add doubles (floats are represented as doubles)
  • add longs
  • add integers
  • concatenate strings
It can be used as a unary operator for numbers (double/long/int). 
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:
  • oracle.jdbc.OracleConnection
  • oracle.jdbc.OracleStatement
  • oracle.jdbc.OraclePreparedStatement
  • oracle.jdbc.OracleCallableStatement
  • oracle.jdbc.OracleResultSet

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. 

P

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 ProfileValueSource to use when retrieving profile values configured via the @IfProfileValue annotation. 

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. 

Q

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:
  • : CommonsPoolTargetSource
  • % ThreadLocalTargetSource
  • ! PrototypeTargetSource 
  • R

    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. 

    S

    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 ObjectNames 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 BeanFactoryLocator, which accesses shared Spring BeanFactory instances. 

    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

    SpringJUnit4ClassRunner is a custom extension of BlockJUnit4ClassRunner which provides functionality of the Spring TestContext Framework to standard JUnit 4.5+ tests by means of the TestContextManager and associated support classes and annotations. 

    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. 

    T

    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

    TestContextManager is the main entry point into the Spring TestContext Framework, which provides support for loading and accessing application contexts, dependency injection of test instances, transactional execution of test methods, etc. 

    TestExecutionListener

    TestExecutionListener defines a listener API for reacting to test execution events published by the TestContextManager with which the listener is registered. 

    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

    TestExecutionListener which provides support for executing tests within transactions by using @Transactional and @NotTransactional annotations. 

    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. 

    U

    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. 

    V

    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. 

    W

    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. 

    X

    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.