InitializingBean

org.springframework.beans.factory.InitializingBean

Known Indirect Subclasses

AbstractCacheManager, AbstractColumnMaxValueIncrementer, AbstractDataFieldMaxValueIncrementer, AbstractEntityManagerFactoryBean, AbstractFactoryBean<T>, AbstractJasperReportsSingleFormatView, AbstractJasperReportsView, AbstractJaxWsServiceExporter, AbstractJmsListeningContainer, AbstractMessageListenerContainer, AbstractPdfStamperView, AbstractPollingMessageListenerContainer, AbstractRefreshableConfigApplicationContext, AbstractRefreshablePortletApplicationContext, AbstractRefreshableWebApplicationContext, and 285 others.

AbstractCacheManager	Abstract base class implementing the common CacheManager methods.
AbstractColumnMaxValueIncrementer	Abstract base class for `DataFieldMaxValueIncrementer` implementations that use a column in a custom sequence table.
AbstractDataFieldMaxValueIncrementer	Base implementation of `DataFieldMaxValueIncrementer` that delegates to a single `getNextKey()` template method that returns a `long`.
AbstractEntityManagerFactoryBean	Abstract `FactoryBean` that creates a local JPA javax.persistence.EntityManagerFactory instance within a Spring application context.
AbstractFactoryBean<T>	Simple template superclass for `FactoryBean` implementations that creates a singleton or a prototype object, depending on a flag.
AbstractJasperReportsSingleFormatView	Extends `AbstractJasperReportsView` to provide basic rendering logic for views that use a fixed format, e.g.
AbstractJasperReportsView	Base class for all JasperReports views.
AbstractJaxWsServiceExporter	Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS javax.jws.WebService annotation).
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).
AbstractMessageListenerContainer	Abstract base class for message listener containers.
AbstractPdfStamperView	Abstract superclass for PDF views that operate on an existing document with an AcroForm.
AbstractPollingMessageListenerContainer	Base class for listener container implementations which are based on polling.
AbstractRefreshableConfigApplicationContext	`AbstractRefreshableApplicationContext` subclass that adds common handling of specified config locations.
AbstractRefreshablePortletApplicationContext	`AbstractRefreshableApplicationContext` subclass which implements the `ConfigurablePortletApplicationContext` interface for portlet environments.
AbstractRefreshableWebApplicationContext	`AbstractRefreshableApplicationContext` subclass which implements the `ConfigurableWebApplicationContext` interface for web environments.
AbstractRemoteSlsbInvokerInterceptor	Base class for interceptors proxying remote Stateless Session Beans.
AbstractRequestLoggingFilter	Base class for `Filter`s that perform logging operations before and after a request is processed.
AbstractRoutingDataSource	Abstract javax.sql.DataSource implementation that routes `getConnection()` calls to one of various target DataSources based on a lookup key.
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.
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.
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.
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.
AbstractUrlBasedView	Abstract base class for URL-based views.
AbstractXmlApplicationContext	Convenient base class for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
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.
AnnotationMBeanExporter	Convenient subclass of Spring's standard `MBeanExporter`, activating Java 5 annotation usage for JMX exposure of Spring beans: `ManagedResource`, `ManagedAttribute`, `ManagedOperation`, etc.
AnnotationSessionFactoryBean	Subclass of Spring's standard LocalSessionFactoryBean for Hibernate, supporting JDK 1.5+ annotation metadata for mappings.
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).
BatchSqlUpdate	SqlUpdate subclass that performs batch update operations.
BeanConfigurerSupport	Convenient base class for configurers that can perform Dependency Injection on objects (however they may be created).
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).
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.
CacheAspectSupport	Base class for caching aspects, such as the `CacheInterceptor` or an AspectJ aspect.
CacheInterceptor	AOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure (`Cache`).
CacheProxyFactoryBean	Proxy factory bean for simplified declarative caching handling.
CachingConnectionFactory	`SingleConnectionFactory` subclass that adds javax.jms.Session caching as well javax.jms.MessageProducer caching.
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.
CharacterEncodingFilter	Servlet 2.3/2.4 Filter that allows one to specify a character encoding for requests.
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.
CommonsLogFactoryBean	Factory bean for commons-logging org.apache.commons.logging.Log instances.
CommonsRequestLoggingFilter	Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.
ConcurrentCacheFactoryBean<K, V>	Factory bean for easy configuration of `ConcurrentCache` through Spring.
ConfigurableJasperReportsView	Configurable JasperReports View, allowing to specify the JasperReports exporter to be specified through bean properties rather than through the view class name.
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.
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.
ConversionServiceFactoryBean	A factory providing convenient access to a ConversionService configured with converters appropriate for most environments.
CronTriggerBean	Convenience subclass of Quartz's org.quartz.CronTrigger class, making bean-style usage easier.
CustomValidatorBean	Configurable bean class that exposes a specific JSR-303 Validator through its original interface as well as through the Spring `Validator` 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).
DaoSupport	Generic base class for DAOs, defining template methods for DAO initialization.
DataSourceInitializer	Used to populate a database during initialization.
DataSourceTransactionManager	`PlatformTransactionManager` implementation for a single JDBC javax.sql.DataSource.
DatabaseStartupValidator	Bean that checks if a database has already started up.
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`
DefaultPersistenceUnitManager	Default implementation of the `PersistenceUnitManager` interface.
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.
DelegatingFilterProxy	Proxy for a standard Servlet 2.3 Filter, delegating to a Spring-managed bean that implements the Filter interface.
DerbyMaxValueIncrementer	`DataFieldMaxValueIncrementer` that increments the maximum value of a given Derby table with the equivalent of an auto-increment column.
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.
EmbeddedDatabaseFactoryBean	A subclass of `EmbeddedDatabaseFactory` that implements `FactoryBean` for registration as a Spring bean.
EventPublicationInterceptor	MethodInterceptor Interceptor that publishes an `ApplicationEvent` to all `ApplicationListeners` registered with an `ApplicationEventPublisher` after each successful method invocation.
ExecutorConfigurationSupport	Base class for classes that are setting up a `java.util.concurrent.ExecutorService` (typically a java.util.concurrent.ThreadPoolExecutor).
FieldRetrievingFactoryBean	`FactoryBean` which retrieves a static or non-static field value.
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.
FormattingConversionServiceFactoryBean	A factory providing convenient access to a `FormattingConversionService` configured with converters and formatters for common types such as numbers and datetimes.
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.
FreeMarkerView	View using the FreeMarker template engine.
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.
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.
GenericSqlQuery
GenericStoredProcedure	Concrete implementation making it possible to define the RDBMS stored procedures in an application context without writing a custom Java implementation class.
GlassFishWorkManagerTaskExecutor	Spring TaskExecutor adapter for the GlassFish JCA WorkManager.
H2SequenceMaxValueIncrementer	`DataFieldMaxValueIncrementer` that retrieves the next value of a given H2 Database sequence.
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.
HibernateAccessor	Base class for `HibernateTemplate` and `HibernateInterceptor`, defining common properties such as SessionFactory and flushing behavior.
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.
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()`.
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.
HttpInvokerClientInterceptor	org.aopalliance.intercept.MethodInterceptor for accessing an HTTP invoker service.
HttpInvokerProxyFactoryBean	`FactoryBean` for HTTP invoker proxies.
HttpInvokerServiceExporter	Servlet-API-based HTTP request handler that exports the specified service bean as HTTP invoker service endpoint, accessible via an HTTP invoker proxy.
InterfaceBasedMBeanInfoAssembler	Subclass of `AbstractReflectiveMBeanInfoAssembler` that allows for the management interface of a bean to be defined using arbitrary interfaces.
InternalResourceView	Wrapper for a JSP or other resource within the same web application.
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.
JBossWorkManagerTaskExecutor	Spring TaskExecutor adapter for the JBoss JCA WorkManager.
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.
JasperReportsXlsView	Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in XLS format.
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`
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.
Jaxb2Marshaller	Implementation of the `Marshaller` interface for JAXB 2.0.
JdbcAccessor	Base class for `JdbcTemplate` and other JDBC-accessing DAO helpers, defining common properties such as DataSource and exception translator.
JdbcDaoSupport	Convenient super class for JDBC-based data access objects.
JdbcTemplate	This is the central class in the JDBC core package.
JdoAccessor	Base class for JdoTemplate and JdoInterceptor, defining common properties such as PersistenceManagerFactory and flushing behavior.
JdoDaoSupport	Convenient super class for JDO data access objects.
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.
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.
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.
JmsDestinationAccessor	Base class for `JmsTemplate` and other JMS-accessing gateway helpers, adding destination-related properties to `JmsAccessor's` common properties.
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.
JmsMessageEndpointManager	Extension of the generic JCA 1.5 `GenericMessageEndpointManager`, adding JMS-specific support for ActivationSpec configuration.
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`
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.
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.
JobDetailBean	Convenience subclass of Quartz's org.quartz.JobDetail class, making bean-style usage easier.
JpaAccessor	Base class for JpaTemplate and JpaInterceptor, defining common properties such as EntityManagerFactory and flushing behavior.
JpaDaoSupport	Convenient super class for JPA data access objects.
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.
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.
JstlView	Specialization of `InternalResourceView` for JSTL pages, i.e.
JtaTransactionManager	`PlatformTransactionManager` implementation for JTA, delegating to a backend JTA provider.
KeyNamingStrategy	`ObjectNamingStrategy` implementation that builds `ObjectName` instances from the key used in the "beans" map passed to `MBeanExporter`.
LazyConnectionDataSourceProxy	Proxy for a target DataSource, fetching actual JDBC Connections lazily, i.e.
ListFactoryBean	Simple factory for shared List instances.
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.
LocalEntityManagerFactoryBean	`FactoryBean` that creates a JPA javax.persistence.EntityManagerFactory according to JPA's standard standalone bootstrap contract.
LocalJaxRpcServiceFactoryBean	This class is deprecated. in favor of JAX-WS support in `org.springframework.remoting.jaxws`
LocalJaxWsServiceFactoryBean	`FactoryBean` for locally defined JAX-WS Service references.
LocalPersistenceManagerFactoryBean	`FactoryBean` that creates a JDO javax.jdo.PersistenceManagerFactory.
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.
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.
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.
MBeanClientInterceptor	org.aopalliance.intercept.MethodInterceptor that routes calls to an MBean running on the supplied `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.
MBeanProxyFactoryBean	Creates a proxy to a managed resource running either locally or remotely.
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).
MapCacheManager	Simple cache manager working against a given collection of caches.
MapFactoryBean	Simple factory for shared Map instances.
MappingCommAreaOperation	EIS operation object for access to COMMAREA records.
MappingRecordOperation	EIS operation object that expects mapped input and output objects, converting to and from CCI Records.
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.
MarshallingMessageConverter	Spring JMS `MessageConverter` that uses a `Marshaller` and `Unmarshaller`.
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.
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.
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`
MethodMapTransactionAttributeSource	Simple `TransactionAttributeSource` implementation that allows attributes to be stored per method in a Map.
MultipartFilter	Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver.
MySQLMaxValueIncrementer	`DataFieldMaxValueIncrementer` that increments the maximum value of a given MySQL table with the equivalent of an auto-increment column.
NamedParameterJdbcDaoSupport	Extension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well.
NotificationListenerBean	Helper class that aggregates a javax.management.NotificationListener, a javax.management.NotificationFilter, and an arbitrary handback object.
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).
OC4JJtaTransactionManager	Special `JtaTransactionManager` variant for Oracle OC4J (10.1.3 and higher).
ObjectFactoryCreatingFactoryBean	A `FactoryBean` implementation that returns a value which is an `ObjectFactory` that in turn returns a bean sourced from a `BeanFactory`.
OncePerRequestFilter	Filter base class that guarantees to be just executed once per request, on any servlet container.
OpenEntityManagerInViewFilter	Servlet 2.3 Filter that binds a JPA EntityManager to the thread for the entire processing of the request.
OpenPersistenceManagerInViewFilter	Servlet 2.3 Filter 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.
OracleSequenceMaxValueIncrementer	`DataFieldMaxValueIncrementer` that retrieves the next value of a given Oracle sequence.
PersistenceExceptionTranslationInterceptor	AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.
PortletWrappingController	`Controller` implementation that wraps a portlet instance which it manages internally.
PostgreSQLSequenceMaxValueIncrementer	`DataFieldMaxValueIncrementer` that retrieves the next value of a given PostgreSQL sequence.
PreferencesPlaceholderConfigurer	Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's Preferences API (`java.util.prefs`).
PropertiesFactoryBean	Allows for making a properties file from a classpath location available as Properties instance in a bean factory.
PropertiesMethodNameResolver	The most flexible out-of-the-box implementation of the `MethodNameResolver` interface.
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`.
ProxyFactoryBean	`FactoryBean` that creates a Proxy java.net.Proxy.
RdbmsOperation	An "RDBMS operation" is a multi-threaded, reusable object representing a query, update, or stored procedure call.
RedirectView	View that redirects to an absolute, context relative, or current request relative URL.
RemoteInvocationBasedAccessor	Abstract base class for remote service accessors that are based on serialization of `RemoteInvocation` objects.
RemoteInvocationSerializingExporter	Abstract base class for remote service exporters that explicitly deserialize `RemoteInvocation` objects and serialize `RemoteInvocationResult` objects, for example Spring's HTTP invoker.
RequestContextFilter	Servlet 2.3 Filter that exposes the request to the current thread, through both `LocaleContextHolder` and `RequestContextHolder`.
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.
ResourceBundleViewResolver	`ViewResolver` implementation that uses bean definitions in a ResourceBundle, specified by the bundle basename.
RmiClientInterceptor	org.aopalliance.intercept.MethodInterceptor for accessing conventional RMI services or RMI invokers.
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.
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.
ScheduledTaskRegistrar	Helper bean for registering tasks with a `TaskScheduler`, typically using cron expressions.
SchedulerAccessorBean	Spring bean-style class for accessing a Quartz Scheduler, i.e.
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.
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`.
ServletContextRequestLoggingFilter	Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.
ServletWrappingController	Spring Controller implementation that wraps a servlet instance which it manages internally.
SetFactoryBean	Simple factory for shared Set instances.
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.
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.
SimpleHessianServiceExporter	HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy.
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.
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.
SimpleJdbcDaoSupport	Extension of `JdbcDaoSupport` that exposes a `SimpleJdbcTemplate` as well.
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`
SimpleRecordOperation	EIS operation object that accepts a passed-in CCI input Record and returns a corresponding CCI output Record.
SimpleRemoteSlsbInvokerInterceptor	Basic invoker for a remote Stateless Session Bean.
SimpleRemoteStatelessSessionProxyFactoryBean	Convenient `FactoryBean` for remote SLSB proxies.
SimpleThreadPoolTaskExecutor	Subclass of Quartz's SimpleThreadPool that implements Spring's `TaskExecutor` interface and listens to Spring lifecycle callbacks.
SimpleTriggerBean	Convenience subclass of Quartz's org.quartz.SimpleTrigger class, making bean-style usage easier.
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`
SortedResourcesFactoryBean	`FactoryBean` implementation that takes a list of location Strings and creates a sorted array of `Resource` instances.
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.
SqlCall	RdbmsOperation using a JdbcTemplate and representing a SQL-based call such as a stored procedure or a stored function.
SqlFunction<T>	SQL "function" wrapper for a query that returns a single row of results.
SqlMapClientDaoSupport	Convenient super class for iBATIS SqlMapClient data access objects.
SqlMapClientFactoryBean	`FactoryBean` that creates an iBATIS com.ibatis.sqlmap.client.SqlMapClient.
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.
SqlQuery<T>	Reusable operation object representing a SQL query.
SqlServerMaxValueIncrementer	`DataFieldMaxValueIncrementer` that increments the maximum value of a given SQL Server table with the equivalent of an auto-increment column.
SqlUpdate	Reusable operation object representing a SQL update.
StoredProcedure	Superclass for object abstractions of RDBMS stored procedures.
SybaseAnywhereMaxValueIncrementer	`DataFieldMaxValueIncrementer` that increments the maximum value of a given Sybase SQL Anywhere table with the equivalent of an auto-increment column.
SybaseMaxValueIncrementer	`DataFieldMaxValueIncrementer` that increments the maximum value of a given Sybase SQL Server table with the equivalent of an auto-increment column.
TaskExecutorFactoryBean	FactoryBean for creating ThreadPoolTaskExecutor instances, choosing between the standard concurrent and the backport-concurrent variant.
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`.
ThreadPoolTaskScheduler	Implementation of Spring's `TaskScheduler` interface, wrapping a native java.util.concurrent.ScheduledThreadPoolExecutor.
TilesConfigurer	This class is deprecated. as of Spring 3.0
TilesJstlView	This class is deprecated. as of Spring 3.0
TilesView	This class is deprecated. as of Spring 3.0
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`
TransactionAspectSupport	Base class for transactional aspects, such as the `TransactionInterceptor` or an AspectJ aspect.
TransactionAwareConnectionFactoryProxy	Proxy for a target CCI javax.resource.cci.ConnectionFactory, adding awareness of Spring-managed transactions.
TransactionAwareDataSourceProxy	Proxy for a target JDBC javax.sql.DataSource, adding awareness of Spring-managed transactions.
TransactionInterceptor	AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (`PlatformTransactionManager`).
TransactionProxyFactoryBean	Proxy factory bean for simplified declarative transaction handling.
TransactionTemplate	Template class that simplifies programmatic transaction demarcation and transaction exception handling.
TypeDefinitionBean	Bean that encapsulates a Hibernate type definition.
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.
UrlBasedRemoteAccessor	Abstract base class for classes that access remote services via 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.
VelocityConfigurer	JavaBean to configure Velocity for web usage, via the "configLocation" and/or "velocityProperties" and/or "resourceLoaderPath" bean properties.
VelocityEngineFactoryBean	Factory bean that configures a VelocityEngine and provides it as bean reference.
VelocityLayoutView	VelocityLayoutView emulates the functionality offered by Velocity's VelocityLayoutServlet to ease page composition from different templates.
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.
WebLogicJtaTransactionManager	Special `JtaTransactionManager` variant for BEA WebLogic (9.0 and higher).
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.
WebSphereMBeanServerFactoryBean	`FactoryBean` that obtains a WebSphere javax.management.MBeanServer reference through WebSphere's proprietary `AdminServiceFactory` API, available on WebSphere 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.
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.
XStreamMarshaller	Implementation of the `Marshaller` interface for XStream.
XmlPortletApplicationContext	Portlet-based `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.
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.

Class Overview

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.

An alternative to implementing InitializingBean is specifying a custom init-method, for example in an XML bean definition. For a list of all bean lifecycle methods, see the BeanFactory javadocs.

Summary

Public Methods
abstract void	afterPropertiesSet() Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

Public Methods

public abstract void afterPropertiesSet ()

Also: SpringBeans

Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.

Throws

Exception	in the event of misconfiguration (such as failure to set an essential property) or if initialization fails.

Interfaces

Classes

Exceptions