Eclipse
Eclipse
IDEA
IntelliJ
NetBeans
NetBeans
XpoLog
XpoLog
Library:Spring
Version:2.5.2
Compatibility:JDK 1.5
Interfaces in library Spring.
NamePackageDescription
AbstractMapBasedHandlerMapping.PortletRequestMappingPredicateorg.springframework.web.portlet.handlerPredicate interface for determining a match with a given request.
Advisedorg.springframework.aop.frameworkInterface to be implemented by classes that hold the configuration of a factory of AOP proxies.
AdvisedSupportListenerorg.springframework.aop.frameworkListener to be registered on ProxyCreatorSupport objects Allows for receiving callbacks on activation and change of advice.
Advisororg.springframework.aopBase interface holding AOP advice (action to take at a joinpoint) and a filter determining the applicability of the advice (such as a pointcut).
AdvisorAdapterorg.springframework.aop.framework.adapterInterface allowing extension to the Spring AOP framework to allow handling of new Advisors and Advice types.
AdvisorAdapterRegistryorg.springframework.aop.framework.adapterInterface for registries of Advisor adapters.
AdvisorChainFactoryorg.springframework.aop.frameworkFactory interface for advisor chains.
AfterAdviceorg.springframework.aopCommon marker interface for after advice, such as AfterReturningAdvice and ThrowsAdvice .
AfterReturningAdviceorg.springframework.aopAfter returning advice is invoked only on normal method return, not if an exception is thrown.
AliasRegistryorg.springframework.coreCommon interface for managing aliases.
AnnotatedBeanDefinitionorg.springframework.beans.factory.annotationExtended BeanDefinition interface that exposes AnnotationMetadata about its bean class - without requiring the class to be loaded yet.
AnnotationMetadataorg.springframework.core.typeInterface that defines abstract access to the annotations of a specific class, in a form that does not require that class to be loaded yet.
AopInfrastructureBeanorg.springframework.aop.frameworkMarker interface that indicates a bean that is part of Spring's AOP infrastructure.
AopProxyorg.springframework.aop.frameworkDelegate interface for a configured AOP proxy, allowing for the creation of actual proxy objects.
AopProxyFactoryorg.springframework.aop.frameworkInterface to be implemented by factories that are able to create AOP proxies based on AdvisedSupport configuration objects.
ApplicationContextorg.springframework.contextCentral interface to provide configuration for an application.
ApplicationContextAwareorg.springframework.contextInterface to be implemented by any object that wishes to be notified of the ApplicationContext that it runs in.
ApplicationEventMulticasterorg.springframework.context.eventInterface to be implemented by objects that can manage a number of ApplicationListeners, and publish events to them.
ApplicationEventPublisherorg.springframework.contextInterface that encapsulates event publication functionality.
ApplicationEventPublisherAwareorg.springframework.contextInterface to be implemented by any object that wishes to be notified of the ApplicationEventPublisher (typically the ApplicationContext) that it runs in.
ApplicationListenerorg.springframework.contextInterface to be implemented by application event listeners.
AspectInstanceFactoryorg.springframework.aop.aspectjInterface implemented to provide an instance of an AspectJ aspect.
AspectJAdvisorFactoryorg.springframework.aop.aspectj.annotationInterface for factories that can create Spring AOP Advisors from classes annotated with AspectJ annotation syntax.
AspectJPrecedenceInformationorg.springframework.aop.aspectjInterface to be implemented by types that can supply the information needed to sort advice/advisors by AspectJ's precedence rules.
AsyncTaskExecutororg.springframework.core.taskExtended interface for asynchronous TaskExecutor implementations, offering an overloaded execute(Runnable, long) variant with start timeout parameter.
AttributeAccessororg.springframework.coreInterface defining a generic contract for attaching and accessing metadata to/from arbitrary objects.
Attributesorg.springframework.metadataInterface for accessing attributes at runtime.
AutodetectCapableMBeanInfoAssemblerorg.springframework.jmx.export.assemblerExtends the MBeanInfoAssembler to add autodetection logic.
AutoPopulatingList.ElementFactoryorg.springframework.utilFactory interface for creating elements for an index-based access data structure such as a List .
AutowireCandidateResolverorg.springframework.beans.factory.supportStrategy interface for determining whether a specific bean definition qualifies as an autowire candidate for a specific dependency.
AutowireCapableBeanFactoryorg.springframework.beans.factory.configExtension 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.
BatchPreparedStatementSetterorg.springframework.jdbc.coreBatch update callback interface used by the JdbcTemplate class.
BeanClassLoaderAwareorg.springframework.beans.factoryCallback that allows a bean to be aware of the bean class loader ; that is, the class loader used by the present bean factory to load bean classes.
BeanDefinitionorg.springframework.beans.factory.configA BeanDefinition describes a bean instance, which has property values, constructor argument values, and further information supplied by concrete implementations.
BeanDefinitionDecoratororg.springframework.beans.factory.xmlInterface used by the DefaultBeanDefinitionDocumentReader to handle custom, nested (directly under a <bean>) tags.
BeanDefinitionDocumentReaderorg.springframework.beans.factory.xmlSPI for parsing an XML document that contains Spring bean definitions.
BeanDefinitionParserorg.springframework.beans.factory.xmlInterface used by the DefaultBeanDefinitionDocumentReader to handle custom, top-level (directly under <beans>) tags.
BeanDefinitionReaderorg.springframework.beans.factory.supportSimple interface for bean definition readers.
BeanDefinitionRegistryorg.springframework.beans.factory.supportInterface for registries that hold bean definitions, for example RootBeanDefinition and ChildBeanDefinition instances.
BeanFactoryorg.springframework.beans.factoryThe root interface for accessing a Spring bean container.
BeanFactoryAwareorg.springframework.beans.factoryInterface to be implemented by beans that wish to be aware of their owning BeanFactory .
BeanFactoryLocatororg.springframework.beans.factory.accessDefines a contract for the lookup, use, and release of a BeanFactory , or a BeanFactory subclass such as an ApplicationContext .
BeanFactoryPostProcessororg.springframework.beans.factory.configAllows for custom modification of an application context's bean definitions, adapting the bean property values of the context's underlying bean factory.
BeanFactoryReferenceorg.springframework.beans.factory.accessUsed to track a reference to a BeanFactory obtained through a BeanFactoryLocator .
BeanMetadataElementorg.springframework.beansInterface to be implemented by bean metadata elements that carry a configuration source object.
BeanNameAwareorg.springframework.beans.factoryInterface to be implemented by beans that want to be aware of their bean name in a bean factory.
BeanNameGeneratororg.springframework.beans.factory.supportStrategy interface for generating bean names for bean definitions.
BeanPostProcessororg.springframework.beans.factory.configFactory hook that allows for custom modification of new bean instances, e.g.
BeanReferenceorg.springframework.beans.factory.configInterface that exposes a reference to a bean name in an abstract fashion.
BeanWiringInfoResolverorg.springframework.beans.factory.wiringStrategy interface to be implemented by objects than can resolve bean name information, given a newly instantiated bean object.
BeanWrapperorg.springframework.beansThe central interface of Spring's low-level JavaBeans infrastructure.
BeforeAdviceorg.springframework.aopCommon marker interface for before advice, such as MethodBeforeAdvice .
BindingErrorProcessororg.springframework.validationStrategy for processing DataBinder's missing field errors, and for translating a PropertyAccessException to a FieldError.
BindingResultorg.springframework.validationGeneral interface that represents binding results.
BootstrapContextAwareorg.springframework.jca.contextInterface to be implemented by any object that wishes to be notified of the BootstrapContext (typically determined by the ResourceAdapterApplicationContext ) that it runs in.
BrowserCallbackorg.springframework.jms.coreCallback for browsing the messages in a JMS queue.
CachingDestinationResolverorg.springframework.jms.support.destinationExtension of the DestinationResolver interface, exposing methods for clearing the cache.
CallableStatementCallbackorg.springframework.jdbc.coreGeneric callback interface for code that operates on a CallableStatement.
CallableStatementCreatororg.springframework.jdbc.coreOne of the three central callback interfaces used by the JdbcTemplate class.
CallbackPreferringPlatformTransactionManagerorg.springframework.transaction.supportExtension of the PlatformTransactionManager interface, exposing a method for executing a given callback within a transaction.
CallMetaDataProviderorg.springframework.jdbc.core.metadataInterface specifying the API to be implemented by a class providing call metadata.
CciOperationsorg.springframework.jca.cci.coreInterface that specifies a basic set of CCI operations on an EIS.
ClassFilterorg.springframework.aopFilter that restricts matching of a pointcut or introduction to a given set of target classes.
ClassMetadataorg.springframework.core.typeInterface that defines abstract metadata of a specific class, in a form that does not require that class to be loaded yet.
ComponentDefinitionorg.springframework.beans.factory.parsingInterface that describes the logical view of a set of BeanDefinitions and BeanReferences as presented in some configuration context.
ConcurrentMaporg.springframework.coreCommon interface for a concurrent Map, as exposed by createConcurrentMap(int) .
ConfigurableApplicationContextorg.springframework.contextSPI interface to be implemented by most if not all application contexts.
ConfigurableBeanFactoryorg.springframework.beans.factory.configConfiguration interface to be implemented by most bean factories.
ConfigurableListableBeanFactoryorg.springframework.beans.factory.configConfiguration interface to be implemented by most listable bean factories.
ConfigurablePortletApplicationContextorg.springframework.web.portlet.contextInterface to be implemented by configurable portlet application contexts.
ConfigurablePropertyAccessororg.springframework.beansInterface that encapsulates configuration methods for a PropertyAccessor.
ConfigurableWebApplicationContextorg.springframework.web.contextInterface to be implemented by configurable web application contexts.
ConnectionCallbackorg.springframework.jca.cci.coreGeneric callback interface for code that operates on a CCI Connection.
ConnectionCallbackorg.springframework.jdbc.coreGeneric callback interface for code that operates on a JDBC Connection.
ConnectionFactoryUtils.ResourceFactoryorg.springframework.jms.connectionCallback interface for resource creation.
ConnectionHandleorg.springframework.jdbc.datasourceSimple interface to be implemented by handles for a JDBC Connection.
ConnectionProxyorg.springframework.jdbc.datasourceSubinterface of Connection to be implemented by Connection proxies.
ContextLoaderorg.springframework.test.context

Strategy interface for loading an application context .

ContextResourceorg.springframework.core.ioExtended interface for a resource that is loaded from an enclosing 'context', e.g.
ControlFloworg.springframework.coreInterface to be implemented by objects that can return information about the current call stack.
Controllerorg.springframework.web.portlet.mvcBase 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.
Controllerorg.springframework.web.servlet.mvcBase Controller interface, representing a component that receives HttpServletRequest and HttpServletResponse instances just like a HttpServlet but is able to participate in an MVC workflow.
DatabaseMetaDataCallbackorg.springframework.jdbc.supportA callback interface used by the JdbcUtils class.
DataFieldMaxValueIncrementerorg.springframework.jdbc.support.incrementerInterface that defines contract of incrementing any data store field's maximum value.
DataSourceLookuporg.springframework.jdbc.datasource.lookupStrategy interface for looking up DataSources by name.
DefaultsDefinitionorg.springframework.beans.factory.parsingMarker interface for a defaults definition, extending BeanMetadataElement to inherit source exposure.
DestinationResolverorg.springframework.jms.support.destinationStrategy interface for resolving JMS destinations.
DestructionAwareBeanPostProcessororg.springframework.beans.factory.configSubinterface of BeanPostProcessor that adds a before-destruction callback.
DisposableBeanorg.springframework.beans.factoryInterface to be implemented by beans that want to release resources on destruction.
DisposableSqlTypeValueorg.springframework.jdbc.coreSubinterface of SqlTypeValue that adds a cleanup callback, to be invoked after the value has been set and the corresponding statement has been executed.
DocumentLoaderorg.springframework.beans.factory.xmlStrategy interface for loading an XML Document .
DynamicIntroductionAdviceorg.springframework.aopSubinterface of AOP Alliance Advice that allows additional interfaces to be implemented by an Advice, and available via a proxy using that interceptor.
EditorAwareTagorg.springframework.web.servlet.tagsInterface to be implemented by JSP tags that expose a PropertyEditor for a property that they are currently bound to.
EntityManagerFactoryInfoorg.springframework.orm.jpaMetadata interface for a Spring-managed EntityManagerFactory.
EntityManagerFactoryPlusorg.springframework.orm.jpaExtension 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.
EntityManagerFactoryPlusOperationsorg.springframework.orm.jpaInterface that defines common operations beyond the standard JPA EntityManagerFactory interface, in a vendor-independent fashion.
EntityManagerPlusorg.springframework.orm.jpaExtension 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.
EntityManagerPlusOperationsorg.springframework.orm.jpaInterface that defines common operations beyond the standard JPA EntityManager interface, in a vendor-independent fashion.
EntityManagerProxyorg.springframework.orm.jpaSubinterface of EntityManager to be implemented by EntityManager proxies.
ErrorCodedorg.springframework.coreInterface that can be implemented by exceptions etc that are error coded.
Errorsorg.springframework.validationStores and exposes information about data-binding and validation errors for a specific object.
ExpressionPointcutorg.springframework.aop.supportInterface to be implemented by pointcuts that use String expressions.
FactoryBeanorg.springframework.beans.factoryInterface to be implemented by objects used within a BeanFactory which are themselves factories.
FreeMarkerConfigorg.springframework.web.servlet.view.freemarkerInterface to be implemented by objects that configure and manage a FreeMarker Configuration object in a web environment.
GroovyObjectCustomizerorg.springframework.scripting.groovyStrategy used by GroovyScriptFactory to allow the customization of a created GroovyObject .
HandlerAdapterorg.springframework.web.portletPortlet MVC framework SPI interface, allowing parameterization of core MVC workflow.
HandlerAdapterorg.springframework.web.servletMVC framework SPI interface, allowing parameterization of core MVC workflow.
HandlerExceptionResolverorg.springframework.web.portletInterface to be implemented by objects than can resolve exceptions thrown during handler mapping or execution, in the typical case to error views.
HandlerExceptionResolverorg.springframework.web.servletInterface to be implemented by objects than can resolve exceptions thrown during handler mapping or execution, in the typical case to error views.
HandlerInterceptororg.springframework.web.portletWorkflow interface that allows for customized handler execution chains.
HandlerInterceptororg.springframework.web.servletWorkflow interface that allows for customized handler execution chains.
HandlerMappingorg.springframework.web.portletInterface to be implemented by objects that define a mapping between requests and handler objects.
HandlerMappingorg.springframework.web.servletInterface to be implemented by objects that define a mapping between requests and handler objects.
HibernateCallbackorg.springframework.orm.hibernate3Callback interface for Hibernate code.
HibernateOperationsorg.springframework.orm.hibernate3Interface that specifies a basic set of Hibernate operations, implemented by HibernateTemplate .
HierarchicalBeanFactoryorg.springframework.beans.factorySub-interface implemented by bean factories that can be part of a hierarchy.
HierarchicalMessageSourceorg.springframework.contextSub-interface of MessageSource to be implemented by objects that can resolve messages hierarchically.
HierarchicalThemeSourceorg.springframework.ui.contextSub-interface of ThemeSource to be implemented by objects that can resolve theme messages hierarchically.
HttpInvokerClientConfigurationorg.springframework.remoting.httpinvokerConfiguration interface for executing HTTP invoker requests.
HttpInvokerRequestExecutororg.springframework.remoting.httpinvokerStrategy interface for actual execution of an HTTP invoker request.
HttpRequestHandlerorg.springframework.webPlain handler interface for components that process HTTP requests, analogous to a Servlet.
InitializingBeanorg.springframework.beans.factoryInterface 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.
InputStreamSourceorg.springframework.core.ioSimple interface for objects that are sources for an InputStream .
InstantiationAwareBeanPostProcessororg.springframework.beans.factory.configSubinterface of BeanPostProcessor that adds a before-instantiation callback, and a callback after instantiation but before explicit properties are set or autowiring occurs.
InstantiationModelAwarePointcutAdvisororg.springframework.aop.aspectjInterface to be implemented by Spring AOP Advisors wrapping AspectJ aspects that may have a lazy initialization strategy.
InstantiationStrategyorg.springframework.beans.factory.supportInterface responsible for creating instances corresponding to a root bean definition.
InteractionCallbackorg.springframework.jca.cci.coreGeneric callback interface for code that operates on a CCI Interaction.
InterruptibleBatchPreparedStatementSetterorg.springframework.jdbc.coreExtension of the BatchPreparedStatementSetter interface, adding a batch exhaustion check.
IntroductionAdvisororg.springframework.aopSuperinterface for advisors that perform one or more AOP introductions.
IntroductionAwareMethodMatcherorg.springframework.aopA specialized type of MethodMatcher that takes into account introductions when matching methods.
IntroductionInfoorg.springframework.aopInterface supplying the information necessary to describe an introduction.
IntroductionInterceptororg.springframework.aopSubinterface of AOP Alliance MethodInterceptor that allows additional interfaces to be implemented by the interceptor, and available via a proxy using that interceptor.
JavaMailSenderorg.springframework.mail.javamailExtended MailSender interface for JavaMail, supporting MIME messages both as direct arguments and through preparation callbacks.
JaxRpcServicePostProcessororg.springframework.remoting.jaxrpcCallback interface for post-processing a JAX-RPC Service.
JdbcOperationsorg.springframework.jdbc.coreInterface specifying a basic set of JDBC operations.
JdoCallbackorg.springframework.orm.jdoCallback interface for JDO code.
JdoDialectorg.springframework.orm.jdoSPI strategy that allows for customizing integration with a specific JDO provider, in particular regarding transaction management and exception translation.
JdoOperationsorg.springframework.orm.jdoInterface that specifies a basic set of JDO operations, implemented by JdoTemplate .
JmsActivationSpecFactoryorg.springframework.jms.listener.endpointStrategy interface for creating JCA 1.5 ActivationSpec objects based on a configured JmsActivationSpecConfig object.
JmsOperationsorg.springframework.jms.coreSpecifies a basic set of JMS operations.
JmxAttributeSourceorg.springframework.jmx.export.metadataInterface used by the MetadataMBeanInfoAssembler to read source-level metadata from a managed resource's class.
JndiCallbackorg.springframework.jndiCallback interface to be implemented by classes that need to perform an operation (such as a lookup) in a JNDI context.
JobDetailAwareTriggerorg.springframework.scheduling.quartzInterface to be implemented by Quartz Triggers that are aware of the JobDetail object that they are associated with.
JpaCallbackorg.springframework.orm.jpaCallback interface for JPA code.
JpaDialectorg.springframework.orm.jpaSPI strategy that encapsulates certain functionality that standard JPA 1.0 does not offer, such as access to the underlying JDBC Connection.
JpaOperationsorg.springframework.orm.jpaInterface that specifies a basic set of JPA operations, implemented by JpaTemplate .
JpaVendorAdapterorg.springframework.orm.jpaSPI interface that allows to plug in vendor-specific behavior into Spring's EntityManagerFactory creators.
KeyHolderorg.springframework.jdbc.supportInterface for retrieving keys, typically used for auto-generated keys as potentially returned by JDBC insert statements.
LabeledEnumorg.springframework.core.enumsAn interface for objects that represent a labeled enumeration.
LabeledEnumResolverorg.springframework.core.enumsInterface for looking up LabeledEnum instances.
LastModifiedorg.springframework.web.servlet.mvcSupports last-modified HTTP requests to facilitate content caching.
Lifecycleorg.springframework.contextInterface defining methods for start/stop lifecycle control.
ListableBeanFactoryorg.springframework.beans.factoryExtension 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.
ListenerSessionManagerorg.springframework.jms.listener.serversessionSPI interface for creating and executing JMS Sessions, pre-populated with a specific MessageListener.
LoadTimeWeaverorg.springframework.instrument.classloadingDefines the contract for adding one or more ClassFileTransformers to a ClassLoader .
LoadTimeWeaverAwareorg.springframework.context.weavingInterface to be implemented by any object that wishes to be notified of the application context's default LoadTimeWeaver .
LobCreatororg.springframework.jdbc.support.lobInterface that abstracts potentially database-specific creation of large binary fields and large text fields.
LobHandlerorg.springframework.jdbc.support.lobAbstraction for handling large binary fields and large text fields in specific databases, no matter if represented as simple types or Large OBjects.
LocaleContextorg.springframework.context.i18nStrategy interface for determining the current Locale.
LocaleResolverorg.springframework.web.servletInterface for web-based locale resolution strategies that allows for both locale resolution via the request and locale modification via request and response.
MailMessageorg.springframework.mailThis 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.
MailSenderorg.springframework.mailThis interface defines a strategy for sending simple mails.
MBeanExporterListenerorg.springframework.jmx.exportA listener that allows application code to be notified when an MBean is registered and unregistered via an MBeanExporter .
MBeanExportOperationsorg.springframework.jmx.exportInterface that defines the set of MBean export operations that are intended to be accessed by application developers during application runtime.
MBeanInfoAssemblerorg.springframework.jmx.export.assemblerInterface to be implemented by all classes that can create management interface metadata for a managed resource.
Mergeableorg.springframework.beansInterface representing an object whose value set can be merged with that of a parent object.
MergedBeanDefinitionPostProcessororg.springframework.beans.factory.supportPost-processor callback interface for merged bean definitions at runtime.
MessageCodesResolverorg.springframework.validationStrategy interface for building message codes from validation error codes.
MessageConverterorg.springframework.jms.support.converterStrategy interface that specifies a converter between Java objects and JMS messages.
MessageCreatororg.springframework.jms.coreCreates a JMS message given a Session .
MessagePostProcessororg.springframework.jms.coreTo be used with JmsTemplate's send method that convert an object to a message.
MessageSourceorg.springframework.contextStrategy interface for resolving messages, with support for the parameterization and internationalization of such messages.
MessageSourceAwareorg.springframework.contextInterface to be implemented by any object that wishes to be notified of the MessageSource (typically the ApplicationContext) that it runs in.
MessageSourceResolvableorg.springframework.contextInterface for objects that are suitable for message resolution in a MessageSource .
MetadataAwareAspectInstanceFactoryorg.springframework.aop.aspectj.annotationSubinterface of AspectInstanceFactory that returns AspectMetadata associated with AspectJ-annotated classes.
MetadataReaderorg.springframework.core.type.classreadingSimple facade for accessing class metadata, as read by an ASM ClassReader .
MetadataReaderFactoryorg.springframework.core.type.classreadingFactory interface for MetadataReader instances.
MethodBeforeAdviceorg.springframework.aopAdvice invoked before a method is invoked.
MethodMatcherorg.springframework.aopPart of a Pointcut : Checks whether the target method is eligible for advice.
MethodNameResolverorg.springframework.web.servlet.mvc.multiactionInterface 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.
MethodReplacerorg.springframework.beans.factory.supportInterface to be implemented by classes that can reimplement any method on an IoC-managed object: the Method Injection form of Dependency Injection.
MimeMessagePreparatororg.springframework.mail.javamailCallback interface for the preparation of JavaMail MIME messages.
Modelorg.springframework.uiJava-5-specific interface that defines a holder for model attributes.
MultipartActionRequestorg.springframework.web.portlet.multipartInterface which provides additional methods for dealing with multipart content within a portlet request, allowing to access uploaded files.
MultipartFileorg.springframework.web.multipartA representation of an uploaded file received in a multipart request.
MultipartHttpServletRequestorg.springframework.web.multipartProvides additional methods for dealing with multipart content within a servlet request, allowing to access uploaded files.
MultipartRequestorg.springframework.web.multipartThis interface defines the multipart request access operations that are exposed for actual multipart requests.
MultipartResolverorg.springframework.web.multipartA strategy interface for multipart file upload resolution in accordance with RFC 1867.
NamedBeanorg.springframework.beans.factoryCounterpart of BeanNameAware.
NamedParameterJdbcOperationsorg.springframework.jdbc.core.namedparamInterface specifying a basic set of JDBC operations allowing the use of named parameters rather than the traditional '?' placeholders.
NamespaceHandlerorg.springframework.beans.factory.xmlBase interface used by the DefaultBeanDefinitionDocumentReader for handling custom namespaces in a Spring XML configuration file.
NamespaceHandlerResolverorg.springframework.beans.factory.xmlUsed by the DefaultBeanDefinitionDocumentReader to locate a NamespaceHandler implementation for a particular namespace URI.
NativeJdbcExtractororg.springframework.jdbc.support.nativejdbcInterface for extracting native JDBC objects from wrapped objects coming from connection pools.
NativeWebRequestorg.springframework.web.context.requestExtension of the WebRequest interface, exposing the native request and response objects in a generic fashion.
NotificationPublisherorg.springframework.jmx.export.notificationSimple interface allowing Spring-managed MBeans to publish JMX notifications without being aware of how those notifications are being transmitted to the MBeanServer .
NotificationPublisherAwareorg.springframework.jmx.export.notificationInterface to be implemented by any Spring-managed resource that is to be registered with an MBeanServer and wishes to send JMX javax.management.Notifications .
ObjectFactoryorg.springframework.beans.factoryDefines a factory which can return an Object instance (possibly shared or independent) when invoked.
ObjectNamingStrategyorg.springframework.jmx.export.namingStrategy interface that encapsulates the creation of ObjectName instances.
OracleLobHandler.LobCallbackorg.springframework.jdbc.support.lobInternal callback interface for use with createLob.
Orderedorg.springframework.coreInterface that can be implemented by objects that should be orderable, for example in a Collection.
PagedListSourceProviderorg.springframework.beans.supportCallback that provides the source for a reloadable List.
ParameterDisposerorg.springframework.jdbc.coreInterface to be implemented by objects that can close resources allocated by parameters like SqlLobValues.
ParameterizedRowMapperorg.springframework.jdbc.core.simpleExtension of the RowMapper interface, adding type parameterization.
ParameterMapperorg.springframework.jdbc.coreImplement this interface when parameters need to be customized based on the connection.
ParameterNameDiscovererorg.springframework.coreInterface to discover parameter names for methods and constructors.
ParseState.Entryorg.springframework.beans.factory.parsingMarker interface for entries into the ParseState .
PathMatcherorg.springframework.utilStrategy interface for String-based path matching.
PersistenceExceptionTranslatororg.springframework.dao.supportInterface implemented by Spring integrations with data access technologies that throw runtime exceptions, such as JPA, TopLink, JDO and Hibernate.
PersistenceUnitManagerorg.springframework.orm.jpa.persistenceunitInterface that defines an abstraction for finding and managing JPA PersistenceUnitInfos.
PersistenceUnitPostProcessororg.springframework.orm.jpa.persistenceunitCallback interface for post-processing a JPA PersistenceUnitInfo.
PlatformTransactionManagerorg.springframework.transactionThis is the central interface in Spring's transaction infrastructure.
Pointcutorg.springframework.aopCore Spring pointcut abstraction.
PointcutAdvisororg.springframework.aopSuperinterface for all Advisors that are driven by a pointcut.
PoolingConfigorg.springframework.aop.targetConfig interface for a pooling target source.
PortletConfigAwareorg.springframework.web.portlet.contextInterface to be implemented by any object that wishes to be notified of the PortletConfig (typically determined by the PortletApplicationContext) that it runs in.
PortletContextAwareorg.springframework.web.portlet.contextInterface to be implemented by any object that wishes to be notified of the PortletContext (typically determined by the PortletApplicationContext) that it runs in.
PortletMultipartResolverorg.springframework.web.portlet.multipartPortlet version of Spring's multipart resolution strategy for file uploads as defined in RFC 1867.
PreparedStatementCallbackorg.springframework.jdbc.coreGeneric callback interface for code that operates on a PreparedStatement.
PreparedStatementCreatororg.springframework.jdbc.coreOne of the two central callback interfaces used by the JdbcTemplate class.
PreparedStatementSetterorg.springframework.jdbc.coreGeneral callback interface used by the JdbcTemplate class.
PriorityOrderedorg.springframework.coreExtension of the Ordered interface, expressing a 'priority' ordering: Order values expressed by PriorityOrdered objects always apply before order values of 'plain' Ordered values.
ProblemReporterorg.springframework.beans.factory.parsingSPI interface allowing tools and other external processes to handle errors and warnings reported during bean definition parsing.
ProducerCallbackorg.springframework.jms.coreCallback for sending a message to a JMS destination.
ProfileValueSourceorg.springframework.test.annotation

Strategy interface for retrieving profile values for a given testing environment.

PropertiesPersisterorg.springframework.utilStrategy interface for persisting java.util.Properties, allowing for pluggable parsing strategies.
PropertyAccessororg.springframework.beansCommon 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 .
PropertyEditorRegistrarorg.springframework.beansInterface for strategies that register custom property editors with a property editor registry .
PropertyEditorRegistryorg.springframework.beansEncapsulates methods for registering JavaBeans PropertyEditors .
PropertyValuesorg.springframework.beansHolder containing 0 or more PropertyValue objects, typically comprising one update.
ProxyMethodInvocationorg.springframework.aopExtension of the AOP Alliance MethodInvocation interface, allowing access to the proxy that the method invocation was made through.
RawTargetAccessorg.springframework.aopMarker 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).
ReaderEventListenerorg.springframework.beans.factory.parsingInterface that receives callbacks for component, alias and import registrations during a bean definition reading process.
RecordCreatororg.springframework.jca.cci.coreCallback interface for creating a CCI Record instance, usually based on the passed-in CCI RecordFactory.
RecordExtractororg.springframework.jca.cci.coreCallback interface for extracting a result object from a CCI Record instance.
ReflectionUtils.FieldCallbackorg.springframework.utilCallback interface invoked on each field in the hierarchy.
ReflectionUtils.FieldFilterorg.springframework.utilCallback optionally used to filter fields to be operated on by a field callback.
ReflectionUtils.MethodCallbackorg.springframework.utilAction to take on each method.
ReflectionUtils.MethodFilterorg.springframework.utilCallback optionally used to method fields to be operated on by a method callback.
Refreshableorg.springframework.aop.target.dynamicInterface to be implemented by dynamic target objects, which support reloading and optionally polling for updates.
RemoteInvocationExecutororg.springframework.remoting.supportStrategy interface for executing a RemoteInvocation on a target object.
RemoteInvocationFactoryorg.springframework.remoting.supportStrategy interface for creating a RemoteInvocation from an AOP Alliance MethodInvocation .
RequestAttributesorg.springframework.web.context.requestAbstraction for accessing attribute objects associated with a request.
RequestToViewNameTranslatororg.springframework.web.servletStrategy interface for translating an incoming HttpServletRequest into a logical view name when no view name is explicitly supplied.
Resourceorg.springframework.core.ioInterface for a resource descriptor that abstracts from the actual type of underlying resource, such as a file or class path resource.
ResourceLoaderorg.springframework.core.ioStrategy interface for loading resources (e..
ResourceLoaderAwareorg.springframework.contextInterface to be implemented by any object that wishes to be notified of the ResourceLoader (typically the ApplicationContext) that it runs in.
ResourcePatternResolverorg.springframework.core.io.supportStrategy interface for resolving a location pattern (for example, an Ant-style path pattern) into Resource objects.
ResourceTransactionManagerorg.springframework.transaction.supportExtension of the PlatformTransactionManager interface, indicating a native resource transaction manager, operating on a single target resource.
ResponseTimeMonitororg.springframework.utilInterface implemented by objects that can provide performance information as well as a record of the number of times they are accessed.
ResultSetExtractororg.springframework.jdbc.coreCallback interface used by JdbcTemplate 's query methods.
RmiInvocationHandlerorg.springframework.remoting.rmiInterface for RMI invocation handlers instances on the server, wrapping exported services.
RowCallbackHandlerorg.springframework.jdbc.coreAn interface used by JdbcTemplate for processing rows of a ResultSet on a per-row basis.
RowMapperorg.springframework.jdbc.coreAn interface used by JdbcTemplate for mapping rows of a ResultSet on a per-row basis.
SavepointManagerorg.springframework.transactionInterface that specifies an API to programmatically manage transaction savepoints in a generic fashion.
SchedulerContextAwareorg.springframework.scheduling.quartzCallback interface to be implemented by Spring-managed Quartz artifacts that need access to the SchedulerContext (without having natural access to it).
SchedulingAwareRunnableorg.springframework.schedulingExtension of the Runnable interface, adding special callbacks for long-running operations.
SchedulingTaskExecutororg.springframework.schedulingA TaskExecutor extension exposing scheduling characteristics that are relevant to potential task submitters.
Scopeorg.springframework.beans.factory.configStrategy interface used by a ConfigurableBeanFactory , representing a target scope to hold bean instances in.
ScopedObjectorg.springframework.aop.scopeAn AOP introduction interface for scoped objects.
ScopeMetadataResolverorg.springframework.context.annotationStrategy interface for resolving the scope of bean definitions.
ScriptFactoryorg.springframework.scriptingScript definition interface, encapsulating the configuration of a specific script as well as a factory method for creating the actual scripted Java Object.
ScriptSourceorg.springframework.scriptingInterface that defines the source of a script.
SelfNamingorg.springframework.jmx.export.namingInterface that allows infrastructure components to provide their own ObjectNames to the MBeanExporter.
ServerSessionFactoryorg.springframework.jms.listener.serversessionSPI interface to be implemented by components that manage JMS ServerSessions.
ServletConfigAwareorg.springframework.web.contextInterface to be implemented by any object that wishes to be notified of the ServletConfig (typically determined by the WebApplicationContext) that it runs in.
ServletContextAwareorg.springframework.web.contextInterface to be implemented by any object that wishes to be notified of the ServletContext (typically determined by the WebApplicationContext) that it runs in.
SessionAttributeStoreorg.springframework.web.bind.supportStrategy interface for storing model attributes in a backend session.
SessionAwareMessageListenerorg.springframework.jms.listenerVariant of the standard JMS MessageListener interface, offering not only the received Message but also the underlying JMS Session object.
SessionCallbackorg.springframework.jms.coreCallback for executing any number of operations on a provided Session .
SessionFactoryorg.springframework.orm.toplinkThe SessionFactory interface serves as factory for TopLink Sessions, allowing for dependency injection on thread-safe TopLink-based DAOs.
SessionProxyorg.springframework.jms.connectionSubinterface of Session to be implemented by Session proxies.
SessionStatusorg.springframework.web.bind.supportSimple interface that can be injected into handler methods, allowing them to signal that their session processing is complete.
SimpleJdbcCallOperationsorg.springframework.jdbc.core.simpleInterface specifying the API for a Simple JDBC Call implemented by SimpleJdbcCall .
SimpleJdbcInsertOperationsorg.springframework.jdbc.core.simpleInterface specifying the API for a Simple JDBC Insert implemented by SimpleJdbcInsert .
SimpleJdbcOperationsorg.springframework.jdbc.core.simpleJDBC 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.
SingletonBeanRegistryorg.springframework.beans.factory.configInterface that defines a registry for shared bean instances.
SmartClassLoaderorg.springframework.coreInterface to be implemented by a reloading-aware ClassLoader (e.g.
SmartConnectionFactoryorg.springframework.jms.connectionExtension of the javax.jms.ConnectionFactory interface, indicating how to release Connections obtained from it.
SmartDataSourceorg.springframework.jdbc.datasourceExtension of the javax.sql.DataSource interface, to be implemented by special DataSources that return JDBC Connections in an unwrapped fashion.
SmartFactoryBeanorg.springframework.beans.factoryExtension of the FactoryBean interface.
SmartInstantiationAwareBeanPostProcessororg.springframework.beans.factory.configExtension of the InstantiationAwareBeanPostProcessor interface, adding a callback for predicting the eventual type of a processed bean.
SmartSessionBeanorg.springframework.ejb.supportInterface to be implemented by Session Beans that want to expose important state to cooperating classes.
SmartTransactionObjectorg.springframework.transaction.supportInterface 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.
SortDefinitionorg.springframework.beans.supportDefinition for sorting bean instances by a property.
SourceExtractororg.springframework.beans.factory.parsingSimple strategy allowing tools to control how source metadata is attached to the bean definition metadata.
SpringProxyorg.springframework.aopMarker interface implemented by all AOP proxies.
SQLExceptionTranslatororg.springframework.jdbc.supportStrategy interface for translating between SQLExceptions and Spring's data access strategy-agnostic DataAccessException hierarchy.
SqlMapClientCallbackorg.springframework.orm.ibatisCallback interface for data access code that works with the iBATIS SqlMapExecutor interface.
SqlMapClientOperationsorg.springframework.orm.ibatisInterface that specifies a basic set of iBATIS SqlMapClient operations, implemented by SqlMapClientTemplate .
SqlParameterSourceorg.springframework.jdbc.core.namedparamInterface that defines common functionality for objects that can offer parameter values for named SQL parameters, serving as argument for NamedParameterJdbcTemplate operations.
SqlProviderorg.springframework.jdbc.coreInterface to be implemented by objects that can provide SQL strings.
SqlReturnTypeorg.springframework.jdbc.coreInterface to be implemented for retrieving values for more complex database-specific types not supported by the standard CallableStatement.getObject method.
SqlRowSetorg.springframework.jdbc.support.rowsetMirror interface for javax.sql.RowSet, representing disconnected java.sql.ResultSet data.
SqlRowSetMetaDataorg.springframework.jdbc.support.rowsetMeta data interface for Spring's SqlRowSet, analogous to javax.sql.ResultSetMetaData
SqlTypeValueorg.springframework.jdbc.coreInterface to be implemented for setting values for more complex database specific types not supported by the standard setObject method.
StatementCallbackorg.springframework.jdbc.coreGeneric callback interface for code that operates on a JDBC Statement.
StringValueResolverorg.springframework.utilSimple strategy interface for resolving a String value.
TableMetaDataProviderorg.springframework.jdbc.core.metadataInterface specifying the API to be implemented by a class providing table metedata.
TargetClassAwareorg.springframework.aopMinimal interface for exposing the target class behind a proxy.
TargetSourceorg.springframework.aopA 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.
TargetSourceCreatororg.springframework.aop.framework.autoproxyImplementations can create special target sources, such as pooling target sources, for particular beans.
TaskExecutororg.springframework.core.taskSimple task executor interface that abstracts the execution of a Runnable .
TestExecutionListenerorg.springframework.test.context

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

Themeorg.springframework.ui.contextA Theme can resolve theme-specific messages, codes, file paths, etcetera (e.g. CSS and image files in a web environment).
ThemeResolverorg.springframework.web.servletInterface for web-based theme resolution strategies that allows for both theme resolution via the request and theme modification via request and response.
ThemeSourceorg.springframework.ui.contextInterface to be implemented by objects that can resolve Themes .
ThreadLocalTargetSourceStatsorg.springframework.aop.targetStatistics for a ThreadLocal TargetSource.
ThrowawayControllerorg.springframework.web.servlet.mvc.throwawayThrowawayController is an alternative to Spring's default Controller interface, for executable per-request command instances that are not aware of the Servlet API.
ThrowsAdviceorg.springframework.aopTag interface for throws advice.
TopLinkCallbackorg.springframework.orm.toplinkCallback interface for TopLink code.
TopLinkOperationsorg.springframework.orm.toplinkInterface that specifies a basic set of TopLink operations, implemented by TopLinkTemplate .
ToStringStylerorg.springframework.core.styleA strategy interface for pretty-printing toString() methods.
TransactionAnnotationParserorg.springframework.transaction.annotationStrategy interface for parsing known transaction annotation types.
TransactionAttributeorg.springframework.transaction.interceptorThis interface adds a rollbackOn specification to TransactionDefinition.
TransactionAttributeSourceorg.springframework.transaction.interceptorInterface used by TransactionInterceptor.
TransactionCallbackorg.springframework.transaction.supportCallback interface for transactional code.
TransactionDefinitionorg.springframework.transactionInterface that defines Spring-compliant transaction properties.
TransactionFactoryorg.springframework.transaction.jtaStrategy interface for creating JTA Transaction objects based on specified transactional characteristics.
TransactionOperationsorg.springframework.transaction.supportInterface specifying basic transaction execution operations.
TransactionStatusorg.springframework.transactionRepresentation of the status of a transaction.
TransactionSynchronizationorg.springframework.transaction.supportInterface for transaction synchronization callbacks.
TypeConverterorg.springframework.beansInterface that defines type conversion methods.
TypeFilterorg.springframework.core.type.filterBase interface for type filters using a MetadataReader .
Validatororg.springframework.validationA validator for application-specific objects.
ValueStylerorg.springframework.core.styleStrategy that encapsulates value String styling algorithms according to Spring conventions.
VelocityConfigorg.springframework.web.servlet.view.velocityInterface to be implemented by objects that configure and manage a VelocityEngine for automatic lookup in a web environment.
Vieworg.springframework.web.servletMVC View for a web interaction.
ViewResolverorg.springframework.web.servletInterface to be implemented by objects that can resolve views by name.
WeakReferenceMonitor.ReleaseListenerorg.springframework.utilListener that is notified when the handle is being released.
WebApplicationContextorg.springframework.web.contextInterface to provide configuration for a web application.
WebArgumentResolverorg.springframework.web.bind.supportSPI for resolving custom arguments for a specific handler method parameter.
WebBindingInitializerorg.springframework.web.bind.supportCallback interface for initializing a WebDataBinder for performing data binding in the context of a specific web request.
WebRequestorg.springframework.web.context.requestGeneric interface for a web request.
WebRequestInterceptororg.springframework.web.context.requestInterface for general web request interception.
XmlBeanDefinitionParserorg.springframework.beans.factory.xmlStrategy interface for parsing XML bean definitions.
Search