## Uses of Interface
org.springframework.beans.factory.InitializingBean

Packages that use InitializingBean
org.springframework.aop.framework: Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
org.springframework.beans.factory.config: SPI interfaces and configuration-related convenience classes for bean factories.
org.springframework.beans.factory.serviceloader: Support package for the JDK 1.6 ServiceLoader facility.
org.springframework.beans.factory.wiring: Mechanism to determine bean wiring metadata from a bean instance.
org.springframework.cache.ehcache: Support classes for the open source cache EHCache, allowing to set up an EHCache CacheManager and Caches as beans in a Spring context.
org.springframework.context.event: Support classes for application events, like standard context events.
org.springframework.context.support: Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
org.springframework.dao.support: Support classes for DAO implementations, providing miscellaneous utility methods.
org.springframework.ejb.access: This package contains classes that allow easy access to EJBs.
org.springframework.jca.cci.connection: Provides a utility class for easy ConnectionFactory access, a PlatformTransactionManager for local CCI transactions, and various simple ConnectionFactory proxies/adapters.
org.springframework.jca.cci.core.support: Classes supporting the `org.springframework.jca.cci.core` package.
org.springframework.jca.cci.object: The classes in this package represent EIS operations as threadsafe, reusable objects.
org.springframework.jca.endpoint: This package provides a facility for generic JCA message endpoint management.
org.springframework.jca.support: Provides generic support classes for JCA usage within Spring, mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.
org.springframework.jca.work: Convenience classes for scheduling based on the JCA 1.5 WorkManager facility, as supported within JCA 1.5 ResourceAdapters.
org.springframework.jca.work.glassfish: Convenience package for obtaining a GlassFish JCA WorkManager for use in web applications.
org.springframework.jca.work.jboss: Convenience package for obtaining a JBoss JCA WorkManager for use in web applications.
org.springframework.jdbc.core: Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.core.namedparam: JdbcTemplate variant with named parameter support.
org.springframework.jdbc.core.simple: Simplification layer over JdbcTemplate for Java 5 and above.
org.springframework.jdbc.core.support: Classes supporting the `org.springframework.jdbc.core` package.
org.springframework.jdbc.datasource: Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.datasource.lookup: Provides a strategy for looking up JDBC DataSources by name.
org.springframework.jdbc.object: The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
org.springframework.jdbc.support: Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
org.springframework.jdbc.support.incrementer: Provides a support framework for incrementing database table values via sequences, with implementations for various databases.
org.springframework.jms.connection: Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
org.springframework.jms.core: Core package of the JMS support.
org.springframework.jms.core.support: Classes supporting the org.springframework.jms.core package.
org.springframework.jms.listener: This package contains the base message listener container facility.
org.springframework.jms.listener.endpoint: This package provides JCA-based endpoint management for JMS message listeners.
org.springframework.jms.listener.serversession: This package contains the ServerSessionMessageListenerContainer implementation, based on the standard JMS ServerSessionPool API.
org.springframework.jms.remoting: Remoting classes for transparent Java-to-Java remoting via a JMS provider.
org.springframework.jms.support: This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
org.springframework.jms.support.destination: Support classes for Spring's JMS framework.
org.springframework.jmx.access: Provides support for accessing remote MBean resources.
org.springframework.jmx.export: This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.export.annotation: JDK 1.5+ annotations for MBean exposure.
org.springframework.jmx.export.assembler: Provides a strategy for MBeanInfo assembly.
org.springframework.jmx.export.metadata: Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
org.springframework.jmx.export.naming: Provides a strategy for ObjectName creation.
org.springframework.jmx.support: Contains support classes for connecting to local and remote `MBeanServer`s and for exposing an `MBeanServer` to remote clients.
org.springframework.jndi: The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes.
org.springframework.mail.javamail: JavaMail support for Spring's mail infrastructure.
org.springframework.orm.hibernate3: Package providing integration of Hibernate3 with Spring concepts.
org.springframework.orm.hibernate3.annotation: Support package for the Hibernate3 Annotation add-on, which supports EJB3-compliant JDK 1.5+ annotations for mappings.
org.springframework.orm.hibernate3.support: Classes supporting the `org.springframework.orm.hibernate3` package.
org.springframework.orm.ibatis: Package providing integration of iBATIS Database Layer with Spring concepts.
org.springframework.orm.ibatis.support: Classes supporting the `org.springframework.orm.ibatis` package.
org.springframework.orm.jdo: Package providing integration of JDO (Java Date Objects) with Spring concepts.
org.springframework.orm.jdo.support: Classes supporting the `org.springframework.orm.jdo` package.
org.springframework.orm.jpa: Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.orm.jpa.persistenceunit: Internal support for managing JPA persistence units.
org.springframework.orm.jpa.support: Classes supporting the `org.springframework.orm.jpa` package.
org.springframework.orm.toplink: Package providing integration of Oracle TopLink with Spring concepts.
org.springframework.orm.toplink.support: Classes supporting the `org.springframework.orm.toplink` package.
org.springframework.remoting.caucho: This package provides remoting classes for Caucho's Hessian and Burlap protocols: a proxy factory for accessing Hessian/Burlap services, and an exporter for making beans available to Hessian/Burlap clients.
org.springframework.remoting.httpinvoker: Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
org.springframework.remoting.jaxrpc: Remoting classes for Web Services via JAX-RPC.
org.springframework.remoting.jaxws: Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC), as included in Java 6 and Java EE 5.
org.springframework.remoting.rmi: Remoting classes for conventional RMI and transparent remoting via RMI invokers.
org.springframework.remoting.support: Generic support classes for remoting implementations.
org.springframework.scheduling.backportconcurrent: Scheduling convenience classes for the JSR-166 backport Executor mechanism, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as bean in a Spring context.
org.springframework.scheduling.commonj: Convenience classes for scheduling based on the CommonJ WorkManager/TimerManager facility, as supported by IBM WebSphere 6.0+ and BEA WebLogic 9.0+.
org.springframework.scheduling.quartz: Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
org.springframework.scheduling.support: Generic support classes for scheduling.
org.springframework.scheduling.timer: Scheduling convenience classes for the JDK Timer, allowing to set up Timers and ScheduledTimerTasks as beans in a Spring context.
org.springframework.transaction.interceptor: AOP-based solution for declarative transaction demarcation.
org.springframework.transaction.jta: Transaction SPI implementation for JTA.
org.springframework.transaction.support: Support classes for the org.springframework.transaction package.
org.springframework.ui.freemarker: Support classes for setting up FreeMarker within a Spring application context.
org.springframework.ui.velocity: Support classes for setting up Velocity within a Spring application context.
org.springframework.web.context.support: Classes supporting the `org.springframework.web.context` package, such as WebApplicationContext implementations and various utility classes.
org.springframework.web.filter: Provides generic filter base classes allowing for bean-style configuration.
org.springframework.web.multipart.support: Support classes for the multipart resolution framework.
org.springframework.web.portlet.context: Support for Spring's application context concept in a portlet environment, including ApplicationContext implementations and various utility classes.
org.springframework.web.portlet.mvc: Standard controller implementations for the portlet MVC framework that comes with Spring.
org.springframework.web.servlet.mvc: Standard controller implementations for the servlet MVC framework that comes with Spring.
org.springframework.web.servlet.mvc.multiaction: Package allowing MVC Controller implementations to handle requests at method rather than class level.
org.springframework.web.servlet.view: Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.view.document: Support classes for document generation, providing View implementations for PDF and Excel.
org.springframework.web.servlet.view.freemarker: Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.servlet.view.jasperreports: Support classes for the integration of JasperReports as Spring web view technology.
org.springframework.web.servlet.view.tiles: Support classes for the integration of Tiles (included in Struts) as Spring web view technology.
org.springframework.web.servlet.view.velocity: Support classes for the integration of Velocity as Spring web view technology.
org.springframework.web.servlet.view.xslt: Support classes for XSLT, providing a View implementation for XSLT stylesheets.

Uses of InitializingBean in org.springframework.aop.framework

Classes in org.springframework.aop.framework that implement InitializingBean
`class` `AbstractSingletonProxyFactoryBean` Convenient proxy factory bean superclass for proxy factory beans that create only singletons.

Uses of InitializingBean in org.springframework.beans.factory.config

Classes in org.springframework.beans.factory.config that implement InitializingBean
`class` `AbstractFactoryBean` Simple template superclass for `FactoryBean` implementations that creates a singleton or a prototype object, depending on a flag.
`class` `CommonsLogFactoryBean` Factory bean for commons-logging `Log` instances.
`class` `FieldRetrievingFactoryBean` FactoryBean which retrieves a static or non-static field value.
`class` `ListFactoryBean` Simple factory for shared List instances.
`class` `MapFactoryBean` Simple factory for shared Map instances.
`class` `MethodInvokingFactoryBean` FactoryBean which returns a value which is the result of a static or instance method invocation.
`class` `ObjectFactoryCreatingFactoryBean` A `FactoryBean` implementation that returns a value which is an `ObjectFactory` that in turn returns a bean sourced from a `BeanFactory`.
`class` `PreferencesPlaceholderConfigurer` Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's Preferences API (`java.util.prefs`).
`class` `PropertiesFactoryBean` Allows for making a properties file from a classpath location available as Properties instance in a bean factory.
`class` `ServiceLocatorFactoryBean` A `FactoryBean` implementation that takes an interface which must have one or more methods with the signatures `MyType xxx()` or `MyType xxx(MyIdType id)` (typically, `MyService getService()` or `MyService getService(String id)`) and creates a dynamic proxy which implements that interface, delegating to an underlying `BeanFactory`.
`class` `SetFactoryBean` Simple factory for shared Set instances.

Uses of InitializingBean in org.springframework.beans.factory.serviceloader

Classes in org.springframework.beans.factory.serviceloader that implement InitializingBean
`class` `AbstractServiceLoaderBasedFactoryBean` Abstract base class for FactoryBeans operating on the JDK 1.6 `ServiceLoader` facility.
`class` `ServiceFactoryBean` `FactoryBean` that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6 `ServiceLoader` facility.
`class` `ServiceListFactoryBean` `FactoryBean` that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6 `ServiceLoader` facility.
`class` `ServiceLoaderFactoryBean` `FactoryBean` that exposes the JDK 1.6 `ServiceLoader` for the configured service class.

Uses of InitializingBean in org.springframework.beans.factory.wiring

Classes in org.springframework.beans.factory.wiring that implement InitializingBean
`class` `BeanConfigurerSupport` Convenient base class for configurers that can perform Dependency Injection on objects (however they may be created).

Uses of InitializingBean in org.springframework.cache.ehcache

Classes in org.springframework.cache.ehcache that implement InitializingBean
`class` `EhCacheFactoryBean` FactoryBean that creates a named EHCache `Cache` instance (or a decorator that implements the `Ehcache` interface), representing a cache region within an EHCache `CacheManager`.
`class` `EhCacheManagerFactoryBean` FactoryBean that exposes an EHCache `CacheManager` instance (independent or shared), configured from a specified config location.

Uses of InitializingBean in org.springframework.context.event

Classes in org.springframework.context.event that implement InitializingBean
`class` `EventPublicationInterceptor` `Interceptor` that publishes an `ApplicationEvent` to all `ApplicationListeners` registered with an `ApplicationEventPublisher` after each successful method invocation.

Uses of InitializingBean in org.springframework.context.support

Classes in org.springframework.context.support that implement InitializingBean
`class` `AbstractRefreshableConfigApplicationContext` `AbstractRefreshableApplicationContext` subclass that adds common handling of specified config locations.
`class` `AbstractXmlApplicationContext` Convenient base class for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
`class` `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.
`class` `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.
`class` `ResourceMapFactoryBean` FactoryBean that creates a Map with String keys and Resource values from properties, interpreting passed-in String values as resource locations.

Uses of InitializingBean in org.springframework.dao.support

Classes in org.springframework.dao.support that implement InitializingBean
`class` `DaoSupport` Generic base class for DAOs, defining template methods for DAO initialization.
`class` `PersistenceExceptionTranslationInterceptor` AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.

Uses of InitializingBean in org.springframework.ejb.access

Classes in org.springframework.ejb.access that implement InitializingBean
`class` `AbstractRemoteSlsbInvokerInterceptor` Base class for interceptors proxying remote Stateless Session Beans.
`class` `AbstractSlsbInvokerInterceptor` Base class for AOP interceptors invoking local or remote Stateless Session Beans.
`class` `LocalSlsbInvokerInterceptor` Invoker for a local Stateless Session Bean.
`class` `LocalStatelessSessionProxyFactoryBean` Convenient factory for local Stateless Session Bean (SLSB) proxies.
`class` `SimpleRemoteSlsbInvokerInterceptor` Basic invoker for a remote Stateless Session Bean.
`class` `SimpleRemoteStatelessSessionProxyFactoryBean` Convenient factory for remote SLSB proxies.

Uses of InitializingBean in org.springframework.jca.cci.connection

Classes in org.springframework.jca.cci.connection that implement InitializingBean
`class` `CciLocalTransactionManager` `PlatformTransactionManager` implementation that manages local transactions for a single CCI ConnectionFactory.
`class` `ConnectionSpecConnectionFactoryAdapter` An adapter for a target CCI `ConnectionFactory`, applying the given ConnectionSpec to every standard `getConnection()` call, that is, implicitly invoking `getConnection(ConnectionSpec)` on the target.
`class` `DelegatingConnectionFactory` CCI `ConnectionFactory` implementation that delegates all calls to a given target `ConnectionFactory`.
`class` `SingleConnectionFactory` A CCI ConnectionFactory adapter that returns the same Connection on all `getConnection` calls, and ignores calls to `Connection.close()`.
`class` `TransactionAwareConnectionFactoryProxy` Proxy for a target CCI `ConnectionFactory`, adding awareness of Spring-managed transactions.

Uses of InitializingBean in org.springframework.jca.cci.core.support

Classes in org.springframework.jca.cci.core.support that implement InitializingBean
`class` `CciDaoSupport` Convenient super class for CCI-based data access objects.

Uses of InitializingBean in org.springframework.jca.cci.object

Classes in org.springframework.jca.cci.object that implement InitializingBean
`class` `EisOperation` Base class for EIS operation objects that work with the CCI API.
`class` `MappingCommAreaOperation` EIS operation object for access to COMMAREA records.
`class` `MappingRecordOperation` EIS operation object that expects mapped input and output objects, converting to and from CCI Records.
`class` `SimpleRecordOperation` EIS operation object that accepts a passed-in CCI input Record and returns a corresponding CCI output Record.

Uses of InitializingBean in org.springframework.jca.endpoint

Classes in org.springframework.jca.endpoint that implement InitializingBean
`class` `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.

Uses of InitializingBean in org.springframework.jca.support

Classes in org.springframework.jca.support that implement InitializingBean
`class` `LocalConnectionFactoryBean` `FactoryBean` that creates a local JCA connection factory in "non-managed" mode (as defined by the Java Connector Architecture specification).
`class` `ResourceAdapterFactoryBean` `FactoryBean` that bootstraps the specified JCA 1.5 `ResourceAdapter`, starting it with a local `BootstrapContext` and exposing it for bean references.

Uses of InitializingBean in org.springframework.jca.work

Classes in org.springframework.jca.work that implement InitializingBean
`class` `WorkManagerTaskExecutor` `TaskExecutor` implementation that delegates to a JCA 1.5 WorkManager, implementing the `WorkManager` interface.

Uses of InitializingBean in org.springframework.jca.work.glassfish

Classes in org.springframework.jca.work.glassfish that implement InitializingBean
`class` `GlassFishWorkManagerTaskExecutor` Spring TaskExecutor adapter for the GlassFish JCA WorkManager.

Uses of InitializingBean in org.springframework.jca.work.jboss

Classes in org.springframework.jca.work.jboss that implement InitializingBean
`class` `JBossWorkManagerTaskExecutor` Spring TaskExecutor adapter for the JBoss JCA WorkManager.

Uses of InitializingBean in org.springframework.jdbc.core

Classes in org.springframework.jdbc.core that implement InitializingBean
`class` `JdbcTemplate` This is the central class in the JDBC core package.

Uses of InitializingBean in org.springframework.jdbc.core.namedparam

Classes in org.springframework.jdbc.core.namedparam that implement InitializingBean
`class` `NamedParameterJdbcDaoSupport` Extension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well.

Uses of InitializingBean in org.springframework.jdbc.core.simple

Classes in org.springframework.jdbc.core.simple that implement InitializingBean
`class` `SimpleJdbcDaoSupport` Extension of `JdbcDaoSupport` that exposes a `SimpleJdbcTemplate` as well.

Uses of InitializingBean in org.springframework.jdbc.core.support

Classes in org.springframework.jdbc.core.support that implement InitializingBean
`class` `JdbcDaoSupport` Convenient super class for JDBC-based data access objects.

Uses of InitializingBean in org.springframework.jdbc.datasource

Classes in org.springframework.jdbc.datasource that implement InitializingBean
`class` `DataSourceTransactionManager` `PlatformTransactionManager` implementation for a single JDBC `DataSource`.
`class` `DelegatingDataSource` JDBC `DataSource` implementation that delegates all calls to a given target `DataSource`.
`class` `IsolationLevelDataSourceAdapter` An adapter for a target `DataSource`, applying the current Spring transaction's isolation level (and potentially specified user credentials) to every `getConnection` call.
`class` `LazyConnectionDataSourceProxy` Proxy for a target DataSource, fetching actual JDBC Connections lazily, i.e. not until first creation of a Statement.
`class` `TransactionAwareDataSourceProxy` Proxy for a target JDBC `DataSource`, adding awareness of Spring-managed transactions.
`class` `UserCredentialsDataSourceAdapter` An adapter for a target JDBC `DataSource`, applying the specified user credentials to every standard `getConnection()` call, implicitly invoking `getConnection(username, password)` on the target.
`class` `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.

Uses of InitializingBean in org.springframework.jdbc.datasource.lookup

Classes in org.springframework.jdbc.datasource.lookup that implement InitializingBean
`class` `AbstractRoutingDataSource` Abstract `DataSource` implementation that routes `AbstractRoutingDataSource.getConnection()` calls to one of various target DataSources based on a lookup key.
`class` `IsolationLevelDataSourceRouter` DataSource that routes to one of various target DataSources based on the current transaction isolation level.

Uses of InitializingBean in org.springframework.jdbc.object

Classes in org.springframework.jdbc.object that implement InitializingBean
`class` `BatchSqlUpdate` SqlUpdate subclass that performs batch update operations.
`class` `MappingSqlQuery` 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.
`class` `MappingSqlQueryWithParameters` 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.
`class` `RdbmsOperation` An "RDBMS operation" is a multi-threaded, reusable object representing a query, update, or stored procedure call.
`class` `SqlCall` RdbmsOperation using a JdbcTemplate and representing a SQL-based call such as a stored procedure or a stored function.
`class` `SqlFunction` SQL "function" wrapper for a query that returns a single row of results.
`class` `SqlOperation` Operation object representing a SQL-based operation such as a query or update, as opposed to a stored procedure.
`class` `SqlQuery` Reusable operation object representing a SQL query.
`class` `SqlUpdate` Reusable operation object representing a SQL update.
`class` `StoredProcedure` Superclass for object abstractions of RDBMS stored procedures.
`class` `UpdatableSqlQuery` 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.

Uses of InitializingBean in org.springframework.jdbc.support

Classes in org.springframework.jdbc.support that implement InitializingBean
`class` `DatabaseStartupValidator` Bean that checks if a database has already started up.
`class` `JdbcAccessor` Base class for `JdbcTemplate` and other JDBC-accessing DAO helpers, defining common properties such as DataSource and exception translator.

Uses of InitializingBean in org.springframework.jdbc.support.incrementer

Classes in org.springframework.jdbc.support.incrementer that implement InitializingBean
`class` `AbstractColumnMaxValueIncrementer` Abstract base class for `DataFieldMaxValueIncrementer` implementations that use a column in a custom sequence table.
`class` `AbstractDataFieldMaxValueIncrementer` Base implementation of `DataFieldMaxValueIncrementer` that delegates to a single `AbstractDataFieldMaxValueIncrementer.getNextKey()` template method that returns a `long`.
`class` `AbstractSequenceMaxValueIncrementer` Abstract base class for `DataFieldMaxValueIncrementer` implementations that use a database sequence.
`class` `DB2MainframeSequenceMaxValueIncrementer` `DataFieldMaxValueIncrementer` that retrieves the next value of a given sequence on DB2/390 or DB2/400.
`class` `DB2SequenceMaxValueIncrementer` `DataFieldMaxValueIncrementer` that retrieves the next value of a given sequence on DB2 UDB (for Unix and Windows).
`class` `DerbyMaxValueIncrementer` `DataFieldMaxValueIncrementer` that increments the maximum value of a given Derby table with the equivalent of an auto-increment column.
`class` `H2SequenceMaxValueIncrementer` `DataFieldMaxValueIncrementer` that retrieves the next value of a given H2 Database sequence.
`class` `HsqlMaxValueIncrementer` `DataFieldMaxValueIncrementer` that increments the maximum value of a given HSQL table with the equivalent of an auto-increment column.
`class` `HsqlSequenceMaxValueIncrementer` `DataFieldMaxValueIncrementer` that retrieves the next value of a given HSQL sequence.
`class` `MySQLMaxValueIncrementer` `DataFieldMaxValueIncrementer` that increments the maximum value of a given MySQL table with the equivalent of an auto-increment column.
`class` `OracleSequenceMaxValueIncrementer` `DataFieldMaxValueIncrementer` that retrieves the next value of a given Oracle sequence.
`class` `PostgreSQLSequenceMaxValueIncrementer` `DataFieldMaxValueIncrementer` that retrieves the next value of a given PostgreSQL sequence.
`class` `SqlServerMaxValueIncrementer` `DataFieldMaxValueIncrementer` that increments the maximum value of a given SQL Server table with the equivalent of an auto-increment column.
`class` `SybaseMaxValueIncrementer` `DataFieldMaxValueIncrementer` that increments the maximum value of a given SQL Server table with the equivalent of an auto-increment column.

Uses of InitializingBean in org.springframework.jms.connection

Classes in org.springframework.jms.connection that implement InitializingBean
`class` `CachingConnectionFactory` `SingleConnectionFactory` subclass that adds `Session` caching as well `MessageProducer` caching.
`class` `JmsTransactionManager` `PlatformTransactionManager` implementation for a single JMS `ConnectionFactory`.
`class` `JmsTransactionManager102` A subclass of `JmsTransactionManager` for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like JmsTransactionManager itself.
`class` `SingleConnectionFactory102` A subclass of `SingleConnectionFactory` for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like SingleConnectionFactory itself.
`class` `UserCredentialsConnectionFactoryAdapter` An adapter for a target JMS `ConnectionFactory`, applying the given user credentials to every standard `createConnection()` call, that is, implicitly invoking `createConnection(username, password)` on the target.

Uses of InitializingBean in org.springframework.jms.core

Classes in org.springframework.jms.core that implement InitializingBean
`class` `JmsTemplate` Helper class that simplifies synchronous JMS access code.
`class` `JmsTemplate102` A subclass of `JmsTemplate` for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like JmsTemplate itself.

Uses of InitializingBean in org.springframework.jms.core.support

Classes in org.springframework.jms.core.support that implement InitializingBean
`class` `JmsGatewaySupport` Convenient super class for application classes that need JMS access.

Uses of InitializingBean in org.springframework.jms.listener

Classes in org.springframework.jms.listener that implement InitializingBean
`class` `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).
`class` `AbstractMessageListenerContainer` Abstract base class for message listener containers.
`class` `AbstractPollingMessageListenerContainer` Base class for listener container implementations which are based on polling.
`class` `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).
`class` `DefaultMessageListenerContainer102` A subclass of `DefaultMessageListenerContainer` for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like SimpleMessageListenerContainer itself.
`class` `SimpleMessageListenerContainer` Message listener container that uses the plain JMS client API's `MessageConsumer.setMessageListener()` method to create concurrent MessageConsumers for the specified listeners.
`class` `SimpleMessageListenerContainer102` A subclass of `SimpleMessageListenerContainer` for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like SimpleMessageListenerContainer itself.

Uses of InitializingBean in org.springframework.jms.listener.endpoint

Classes in org.springframework.jms.listener.endpoint that implement InitializingBean
`class` `JmsMessageEndpointManager` Extension of the generic JCA 1.5 `GenericMessageEndpointManager`, adding JMS-specific support for ActivationSpec configuration.

Uses of InitializingBean in org.springframework.jms.listener.serversession

Classes in org.springframework.jms.listener.serversession that implement InitializingBean
`class` `ServerSessionMessageListenerContainer` Deprecated. as of Spring 2.5, in favor of DefaultMessageListenerContainer and JmsMessageEndpointManager. To be removed in Spring 3.0.
`class` `ServerSessionMessageListenerContainer102` Deprecated. as of Spring 2.5, in favor of DefaultMessageListenerContainer and JmsMessageEndpointManager. To be removed in Spring 3.0.

Uses of InitializingBean in org.springframework.jms.remoting

Classes in org.springframework.jms.remoting that implement InitializingBean
`class` `JmsInvokerClientInterceptor` `MethodInterceptor` for accessing a JMS-based remote service.
`class` `JmsInvokerProxyFactoryBean` FactoryBean for JMS invoker proxies.
`class` `JmsInvokerServiceExporter` JMS message listener that exports the specified service bean as a JMS service endpoint, accessible via a JMS invoker proxy.

Uses of InitializingBean in org.springframework.jms.support

Classes in org.springframework.jms.support that implement InitializingBean
`class` `JmsAccessor` Base class for `JmsTemplate` and other JMS-accessing gateway helpers, defining common properties such as the JMS `ConnectionFactory` to operate on.

Uses of InitializingBean in org.springframework.jms.support.destination

Classes in org.springframework.jms.support.destination that implement InitializingBean
`class` `JmsDestinationAccessor` Base class for `JmsTemplate` and other JMS-accessing gateway helpers, adding destination-related properties to `JmsAccessor's` common properties.

Uses of InitializingBean in org.springframework.jmx.access

Classes in org.springframework.jmx.access that implement InitializingBean
`class` `MBeanClientInterceptor` `MethodInterceptor` that routes calls to an MBean running on the supplied `MBeanServerConnection`.
`class` `MBeanProxyFactoryBean` Creates a proxy to a managed resource running either locally or remotely.
`class` `NotificationListenerRegistrar` Registrar object that associates a specific `NotificationListener` with one or more MBeans in an `MBeanServer` (typically via a `MBeanServerConnection`).

Uses of InitializingBean in org.springframework.jmx.export

Classes in org.springframework.jmx.export that implement InitializingBean
`class` `MBeanExporter` JMX exporter that allows for exposing any Spring-managed bean to a JMX `MBeanServer`, without the need to define any JMX-specific information in the bean classes.
`class` `NotificationListenerBean` Helper class that aggregates a `NotificationListener`, a `NotificationFilter`, and an arbitrary handback object.

Uses of InitializingBean in org.springframework.jmx.export.annotation

Classes in org.springframework.jmx.export.annotation that implement InitializingBean
`class` `AnnotationMBeanExporter` Convenient subclass of Spring's standard `MBeanExporter`, activating Java 5 annotation usage for JMX exposure of Spring beans: `ManagedResource`, `ManagedAttribute`, `ManagedOperation`, etc.

Uses of InitializingBean in org.springframework.jmx.export.assembler

Classes in org.springframework.jmx.export.assembler that implement InitializingBean
`class` `InterfaceBasedMBeanInfoAssembler` Subclass of `AbstractReflectiveMBeanInfoAssembler` that allows for the management interface of a bean to be defined using arbitrary interfaces.
`class` `MetadataMBeanInfoAssembler` Implementation of the `MBeanInfoAssembler` interface that reads the management interface information from source level metadata.

Uses of InitializingBean in org.springframework.jmx.export.metadata

Classes in org.springframework.jmx.export.metadata that implement InitializingBean
`class` `AttributesJmxAttributeSource` Implementation of the `JmxAttributeSource` interface that reads metadata via Spring's `Attributes` abstraction.

Uses of InitializingBean in org.springframework.jmx.export.naming

Classes in org.springframework.jmx.export.naming that implement InitializingBean
`class` `KeyNamingStrategy` `ObjectNamingStrategy` implementation that builds `ObjectName` instances from the key used in the "beans" map passed to `MBeanExporter`.
`class` `MetadataNamingStrategy` An implementation of the `ObjectNamingStrategy` interface that reads the `ObjectName` from the source-level metadata.

Uses of InitializingBean in org.springframework.jmx.support

Classes in org.springframework.jmx.support that implement InitializingBean
`class` `ConnectorServerFactoryBean` `FactoryBean` that creates a JSR-160 `JMXConnectorServer`, optionally registers it with the `MBeanServer` and then starts it.
`class` `MBeanServerConnectionFactoryBean` `FactoryBean` that creates a JMX 1.2 `MBeanServerConnection` to a remote `MBeanServer` exposed via a `JMXServerConnector`.
`class` `MBeanServerFactoryBean` FactoryBean that obtains an `MBeanServer` reference through the standard JMX 1.2 `MBeanServerFactory` API (which is available on JDK 1.5 or as part of a JMX 1.2 provider).
`class` `WebLogicJndiMBeanServerFactoryBean` FactoryBean that obtains a specified WebLogic `MBeanServer` reference through a WebLogic `MBeanHome` obtained via a JNDI lookup.
`class` `WebLogicMBeanServerFactoryBean` FactoryBean that obtains a specified WebLogic `MBeanServer` reference through WebLogic's proprietary `Helper` / `MBeanHome` API, which is available on WebLogic 6.1 and higher.
`class` `WebSphereMBeanServerFactoryBean` FactoryBean that obtains a WebSphere `MBeanServer` reference through WebSphere's proprietary `AdminServiceFactory` API, available on WebSphere 5.1 and higher.

Uses of InitializingBean in org.springframework.jndi

Classes in org.springframework.jndi that implement InitializingBean
`class` `JndiObjectFactoryBean` `FactoryBean` that looks up a JNDI object.
`class` `JndiObjectLocator` Convenient superclass for JNDI-based service locators, providing configurable lookup of a specific JNDI resource.
`class` `JndiObjectTargetSource` AOP `TargetSource` that provides configurable JNDI lookups for `getTarget()` calls.

Uses of InitializingBean in org.springframework.mail.javamail

Classes in org.springframework.mail.javamail that implement InitializingBean
`class` `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.

Uses of InitializingBean in org.springframework.orm.hibernate3

Classes in org.springframework.orm.hibernate3 that implement InitializingBean
`class` `AbstractSessionFactoryBean` Abstract `FactoryBean` that creates a Hibernate `SessionFactory` within a Spring application context, providing general infrastructure not related to Hibernate's specific configuration API.
`class` `FilterDefinitionFactoryBean` Convenient FactoryBean for defining Hibernate FilterDefinitions.
`class` `HibernateAccessor` Base class for `HibernateTemplate` and `HibernateInterceptor`, defining common properties such as SessionFactory and flushing behavior.
`class` `HibernateInterceptor` This interceptor binds a new Hibernate Session to the thread before a method call, closing and removing it afterwards in case of any method outcome.
`class` `HibernateTemplate` Helper class that simplifies Hibernate data access code.
`class` `HibernateTransactionManager` `PlatformTransactionManager` implementation for a single Hibernate `SessionFactory`.
`class` `LocalSessionFactoryBean` `FactoryBean` that creates a Hibernate `SessionFactory`.
`class` `TypeDefinitionBean` Bean that encapsulates a Hibernate type definition.

Uses of InitializingBean in org.springframework.orm.hibernate3.annotation

Classes in org.springframework.orm.hibernate3.annotation that implement InitializingBean
`class` `AnnotationSessionFactoryBean` Subclass of Spring's standard LocalSessionFactoryBean for Hibernate, supporting JDK 1.5+ annotation metadata for mappings.

Uses of InitializingBean in org.springframework.orm.hibernate3.support

Classes in org.springframework.orm.hibernate3.support that implement InitializingBean
`class` `HibernateDaoSupport` Convenient super class for Hibernate-based data access objects.
`class` `OpenSessionInViewFilter` Servlet 2.3 Filter that binds a Hibernate Session to the thread for the entire processing of the request.
`class` `OpenSessionInViewInterceptor` Spring web request interceptor that binds a Hibernate `Session` to the thread for the entire processing of the request.

Uses of InitializingBean in org.springframework.orm.ibatis

Classes in org.springframework.orm.ibatis that implement InitializingBean
`class` `SqlMapClientFactoryBean` `FactoryBean` that creates an iBATIS `SqlMapClient`.
`class` `SqlMapClientTemplate` Helper class that simplifies data access via the iBATIS `SqlMapClient` API, converting checked SQLExceptions into unchecked DataAccessExceptions, following the `org.springframework.dao` exception hierarchy.

Uses of InitializingBean in org.springframework.orm.ibatis.support

Classes in org.springframework.orm.ibatis.support that implement InitializingBean
`class` `SqlMapClientDaoSupport` Convenient super class for iBATIS SqlMapClient data access objects.

Uses of InitializingBean in org.springframework.orm.jdo

Classes in org.springframework.orm.jdo that implement InitializingBean
`class` `JdoAccessor` Base class for JdoTemplate and JdoInterceptor, defining common properties such as PersistenceManagerFactory and flushing behavior.
`class` `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.
`class` `JdoTemplate` Helper class that simplifies JDO data access code, and converts JDOExceptions into Spring DataAccessExceptions, following the `org.springframework.dao` exception hierarchy.
`class` `JdoTransactionManager` `PlatformTransactionManager` implementation for a single JDO `PersistenceManagerFactory`.
`class` `LocalPersistenceManagerFactoryBean` `FactoryBean` that creates a JDO `PersistenceManagerFactory`.

Uses of InitializingBean in org.springframework.orm.jdo.support

Classes in org.springframework.orm.jdo.support that implement InitializingBean
`class` `JdoDaoSupport` Convenient super class for JDO data access objects.
`class` `OpenPersistenceManagerInViewFilter` Servlet 2.3 Filter that binds a JDO PersistenceManager to the thread for the entire processing of the request.

Uses of InitializingBean in org.springframework.orm.jpa

Classes in org.springframework.orm.jpa that implement InitializingBean
`class` `AbstractEntityManagerFactoryBean` Abstract `FactoryBean` that creates a local JPA `EntityManagerFactory` instance within a Spring application context.
`class` `JpaAccessor` Base class for JpaTemplate and JpaInterceptor, defining common properties such as EntityManagerFactory and flushing behavior.
`class` `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.
`class` `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.
`class` `JpaTransactionManager` `PlatformTransactionManager` implementation for a single JPA `EntityManagerFactory`.
`class` `LocalContainerEntityManagerFactoryBean` `FactoryBean` that creates a JPA `EntityManagerFactory` according to JPA's standard container bootstrap contract.
`class` `LocalEntityManagerFactoryBean` `FactoryBean` that creates a JPA `EntityManagerFactory` according to JPA's standard standalone bootstrap contract.

Uses of InitializingBean in org.springframework.orm.jpa.persistenceunit

Classes in org.springframework.orm.jpa.persistenceunit that implement InitializingBean
`class` `DefaultPersistenceUnitManager` Default implementation of the `PersistenceUnitManager` interface.

Uses of InitializingBean in org.springframework.orm.jpa.support

Classes in org.springframework.orm.jpa.support that implement InitializingBean
`class` `JpaDaoSupport` Convenient super class for JPA data access objects.
`class` `OpenEntityManagerInViewFilter` Servlet 2.3 Filter that binds a JPA EntityManager to the thread for the entire processing of the request.
`class` `SharedEntityManagerBean` `FactoryBean` that exposes a shared JPA `EntityManager` reference for a given EntityManagerFactory.

Uses of InitializingBean in org.springframework.orm.toplink

Classes in org.springframework.orm.toplink that implement InitializingBean
`class` `TopLinkAccessor` Base class for TopLinkTemplate and TopLinkInterceptor, defining common properties such as SessionFactory and JDBC exception translator.
`class` `TopLinkInterceptor` This interceptor binds a new TopLink Session to the thread before a method call, closing and removing it afterwards in case of any method outcome.
`class` `TopLinkTemplate` Helper class that simplifies TopLink data access code, and converts TopLinkExceptions into unchecked DataAccessExceptions, following the `org.springframework.dao` exception hierarchy.
`class` `TopLinkTransactionManager` `PlatformTransactionManager` implementation for a single TopLink `SessionFactory`.

Uses of InitializingBean in org.springframework.orm.toplink.support

Classes in org.springframework.orm.toplink.support that implement InitializingBean
`class` `TopLinkDaoSupport` Convenient super class for TopLink data access objects.

Uses of InitializingBean in org.springframework.remoting.caucho

Classes in org.springframework.remoting.caucho that implement InitializingBean
`class` `BurlapClientInterceptor` `MethodInterceptor` for accessing a Burlap service.
`class` `BurlapExporter` General stream-based protocol exporter for a Burlap endpoint.
`class` `BurlapProxyFactoryBean` FactoryBean for Burlap proxies.
`class` `BurlapServiceExporter` Servlet-API-based HTTP request handler that exports the specified service bean as Burlap service endpoint, accessible via a Burlap proxy.
`class` `HessianClientInterceptor` `MethodInterceptor` for accessing a Hessian service.
`class` `HessianExporter` General stream-based protocol exporter for a Hessian endpoint.
`class` `HessianProxyFactoryBean` FactoryBean for Hessian proxies.
`class` `HessianServiceExporter` Servlet-API-based HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy.
`class` `SimpleBurlapServiceExporter` HTTP request handler that exports the specified service bean as Burlap service endpoint, accessible via a Burlap proxy.
`class` `SimpleHessianServiceExporter` HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy.

Uses of InitializingBean in org.springframework.remoting.httpinvoker

Classes in org.springframework.remoting.httpinvoker that implement InitializingBean
`class` `HttpInvokerClientInterceptor` `MethodInterceptor` for accessing an HTTP invoker service.
`class` `HttpInvokerProxyFactoryBean` FactoryBean for HTTP invoker proxies.
`class` `HttpInvokerServiceExporter` Servlet-API-based HTTP request handler that exports the specified service bean as HTTP invoker service endpoint, accessible via an HTTP invoker proxy.
`class` `SimpleHttpInvokerServiceExporter` HTTP request handler that exports the specified service bean as HTTP invoker service endpoint, accessible via an HTTP invoker proxy.

Uses of InitializingBean in org.springframework.remoting.jaxrpc

Classes in org.springframework.remoting.jaxrpc that implement InitializingBean
`class` `JaxRpcPortClientInterceptor` `MethodInterceptor` for accessing a specific port of a JAX-RPC service.
`class` `JaxRpcPortProxyFactoryBean` `FactoryBean` for a specific port of a JAX-RPC service.
`class` `LocalJaxRpcServiceFactoryBean` `FactoryBean` for locally defined JAX-RPC Service references.

Uses of InitializingBean in org.springframework.remoting.jaxws

Classes in org.springframework.remoting.jaxws that implement InitializingBean
`class` `AbstractJaxWsServiceExporter` Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS `WebService` annotation).
`class` `JaxWsPortClientInterceptor` `MethodInterceptor` for accessing a specific port of a JAX-WS service.
`class` `JaxWsPortProxyFactoryBean` `FactoryBean` for a specific port of a JAX-WS service.
`class` `LocalJaxWsServiceFactoryBean` `FactoryBean` for locally defined JAX-WS Service references.
`class` `SimpleHttpServerJaxWsServiceExporter` Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS `WebService` annotation) and exporting them through the HTTP server included in Sun's JDK 1.6.
`class` `SimpleJaxWsServiceExporter` Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS `WebService` annotation) and exporting them with a configured base address (by default "http://localhost:8080/") using the JAX-WS provider's built-in publication support.

Uses of InitializingBean in org.springframework.remoting.rmi

Classes in org.springframework.remoting.rmi that implement InitializingBean
`class` `JndiRmiClientInterceptor` `MethodInterceptor` for accessing RMI services from JNDI.
`class` `JndiRmiProxyFactoryBean` Factory bean for RMI proxies from JNDI.
`class` `JndiRmiServiceExporter` Service exporter which binds RMI services to JNDI.
`class` `RemoteInvocationSerializingExporter` Abstract base class for remote service exporters that explicitly deserialize `RemoteInvocation` objects and serialize `RemoteInvocationResult` objects, for example Spring's HTTP invoker.
`class` `RmiClientInterceptor` `MethodInterceptor` for accessing conventional RMI services or RMI invokers.
`class` `RmiProxyFactoryBean` FactoryBean for RMI proxies, supporting both conventional RMI services and RMI invokers.
`class` `RmiRegistryFactoryBean` FactoryBean that locates a `Registry` and exposes it for bean references.
`class` `RmiServiceExporter` RMI exporter that exposes the specified service as RMI object with the specified name.

Uses of InitializingBean in org.springframework.remoting.support

Classes in org.springframework.remoting.support that implement InitializingBean
`class` `RemoteInvocationBasedAccessor` Abstract base class for remote service accessors that are based on serialization of `RemoteInvocation` objects.
`class` `SimpleHttpServerFactoryBean` `FactoryBean` that creates a simple HTTP server, based on the HTTP server that is included in Sun's JRE 1.6.
`class` `UrlBasedRemoteAccessor` Abstract base class for classes that access remote services via URLs.

Uses of InitializingBean in org.springframework.scheduling.backportconcurrent

Classes in org.springframework.scheduling.backportconcurrent that implement InitializingBean
`class` `ScheduledExecutorFactoryBean` `FactoryBean` that sets up a JSR-166 backport `ScheduledExecutorService` (by default: `ScheduledThreadPoolExecutor` as implementation) and exposes it for bean references.
`class` `ThreadPoolTaskExecutor` JavaBean that allows for configuring a JSR-166 backport `ThreadPoolExecutor` in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties), exposing it as a Spring `TaskExecutor`.

Uses of InitializingBean in org.springframework.scheduling.commonj

Classes in org.springframework.scheduling.commonj that implement InitializingBean
`class` `TimerManagerFactoryBean` `FactoryBean` that retrieves a CommonJ `TimerManager` and exposes it for bean references.

Uses of InitializingBean in org.springframework.scheduling.quartz

Classes in org.springframework.scheduling.quartz that implement InitializingBean
`class` `CronTriggerBean` Convenience subclass of Quartz's `CronTrigger` class, making bean-style usage easier.
`class` `JobDetailBean` Convenience subclass of Quartz' JobDetail class that eases bean-style usage.
`class` `MethodInvokingJobDetailFactoryBean` `FactoryBean` that exposes a `JobDetail` object which delegates job execution to a specified (static or non-static) method.
`class` `SchedulerAccessorBean` Spring bean-style class for accessing a Quartz Scheduler, i.e. for registering jobs, triggers and listeners on a given `Scheduler` instance.
`class` `SchedulerFactoryBean` `FactoryBean` that creates and configures a Quartz `Scheduler`, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.
`class` `SimpleThreadPoolTaskExecutor` Subclass of Quartz's SimpleThreadPool that implements Spring's TaskExecutor interface and listens to Spring lifecycle callbacks.
`class` `SimpleTriggerBean` Convenience subclass of Quartz's `SimpleTrigger` class, making bean-style usage easier.

Uses of InitializingBean in org.springframework.scheduling.support

Classes in org.springframework.scheduling.support that implement InitializingBean
`class` `MethodInvokingRunnable` Adapter that implements the `Runnable` interface as a configurable method invocation based on Spring's MethodInvoker.

Uses of InitializingBean in org.springframework.scheduling.timer

Classes in org.springframework.scheduling.timer that implement InitializingBean
`class` `MethodInvokingTimerTaskFactoryBean` FactoryBean that exposes a TimerTask object that delegates job execution to a specified (static or non-static) method.
`class` `TimerFactoryBean` FactoryBean that sets up a `Timer` and exposes it for bean references.
`class` `TimerTaskExecutor` `TaskExecutor` implementation that uses a single `Timer` for executing all tasks, effectively resulting in serialized asynchronous execution on a single thread.

Uses of InitializingBean in org.springframework.transaction.interceptor

Classes in org.springframework.transaction.interceptor that implement InitializingBean
`class` `AttributesTransactionAttributeSource` Implementation of the `TransactionAttributeSource` interface that reads metadata via Spring's `Attributes` abstraction.
`class` `MethodMapTransactionAttributeSource` Simple `TransactionAttributeSource` implementation that allows attributes to be stored per method in a `Map`.
`class` `TransactionAspectSupport` Base class for transactional aspects, such as the AOP Alliance `TransactionInterceptor` or an AspectJ aspect.
`class` `TransactionInterceptor` AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (`PlatformTransactionManager`).
`class` `TransactionProxyFactoryBean` Proxy factory bean for simplified declarative transaction handling.

Uses of InitializingBean in org.springframework.transaction.jta

Classes in org.springframework.transaction.jta that implement InitializingBean
`class` `JtaTransactionManager` `PlatformTransactionManager` implementation for JTA, delegating to a backend JTA provider.
`class` `OC4JJtaTransactionManager` Special `JtaTransactionManager` variant for Oracle OC4J (10.1.3 and higher).
`class` `WebLogicJtaTransactionManager` Special `JtaTransactionManager` variant for BEA WebLogic (7.0, 8.1 and higher).
`class` `WebSphereUowTransactionManager` WebSphere-specific PlatformTransactionManager implementation that delegates to a `UOWManager` instance, obtained from WebSphere's JNDI environment.

Uses of InitializingBean in org.springframework.transaction.support

Classes in org.springframework.transaction.support that implement InitializingBean
`class` `TransactionTemplate` Template class that simplifies programmatic transaction demarcation and transaction exception handling.

Uses of InitializingBean in org.springframework.ui.freemarker

Classes in org.springframework.ui.freemarker that implement InitializingBean
`class` `FreeMarkerConfigurationFactoryBean` Factory bean that creates a FreeMarker Configuration and provides it as bean reference.

Uses of InitializingBean in org.springframework.ui.velocity

Classes in org.springframework.ui.velocity that implement InitializingBean
`class` `VelocityEngineFactoryBean` Factory bean that configures a VelocityEngine and provides it as bean reference.

Uses of InitializingBean in org.springframework.web.context.support

Classes in org.springframework.web.context.support that implement InitializingBean
`class` `AbstractRefreshableWebApplicationContext` `AbstractRefreshableApplicationContext` subclass which implements the `ConfigurableWebApplicationContext` interface for web environments.
`class` `XmlWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

Uses of InitializingBean in org.springframework.web.filter

Classes in org.springframework.web.filter that implement InitializingBean
`class` `AbstractRequestLoggingFilter` Base class for `Filter`s that perform logging operations before and after a request is processed.
`class` `CharacterEncodingFilter` Servlet 2.3/2.4 Filter that allows one to specify a character encoding for requests.
`class` `CommonsRequestLoggingFilter` Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.
`class` `DelegatingFilterProxy` Proxy for a standard Servlet 2.3 Filter, delegating to a Spring-managed bean that implements the Filter interface.
`class` `GenericFilterBean` Simple base implementation of `Filter` which treats its config parameters (`init-param` entries within the `filter` tag in `web.xml`) as bean properties.
`class` `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.
`class` `OncePerRequestFilter` Filter base class that guarantees to be just executed once per request, on any servlet container.
`class` `RequestContextFilter` Servlet 2.3 Filter that exposes the request to the current thread, through both `LocaleContextHolder` and `RequestContextHolder`.
`class` `ServletContextRequestLoggingFilter` Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.

Uses of InitializingBean in org.springframework.web.multipart.support

Classes in org.springframework.web.multipart.support that implement InitializingBean
`class` `MultipartFilter` Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver.

Uses of InitializingBean in org.springframework.web.portlet.context

Classes in org.springframework.web.portlet.context that implement InitializingBean
`class` `AbstractRefreshablePortletApplicationContext` `AbstractRefreshableApplicationContext` subclass which implements the `ConfigurablePortletApplicationContext` interface for portlet environments.
`class` `XmlPortletApplicationContext` Portlet-based `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

Uses of InitializingBean in org.springframework.web.portlet.mvc

Classes in org.springframework.web.portlet.mvc that implement InitializingBean
`class` `PortletWrappingController` `Controller` implementation that wraps a portlet instance which it manages internally.

Uses of InitializingBean in org.springframework.web.servlet.mvc

Classes in org.springframework.web.servlet.mvc that implement InitializingBean
`class` `ServletWrappingController` Spring Controller implementation that wraps a servlet instance which it manages internally.

Uses of InitializingBean in org.springframework.web.servlet.mvc.multiaction

Classes in org.springframework.web.servlet.mvc.multiaction that implement InitializingBean
`class` `PropertiesMethodNameResolver` The most flexible out-of-the-box implementation of the MethodNameResolver interface.

Uses of InitializingBean in org.springframework.web.servlet.view

Classes in org.springframework.web.servlet.view that implement InitializingBean
`class` `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.
`class` `AbstractUrlBasedView` Abstract base class for URL-based views.
`class` `InternalResourceView` Wrapper for a JSP or other resource within the same web application.
`class` `JstlView` Specialization of `InternalResourceView` for JSTL pages, i.e.
`class` `RedirectView` View that redirects to an absolute, context relative, or current request relative URL, by default exposing all model attributes as HTTP query parameters.

Uses of InitializingBean in org.springframework.web.servlet.view.document

Classes in org.springframework.web.servlet.view.document that implement InitializingBean
`class` `AbstractPdfStamperView` Abstract superclass for PDF views that operate on an existing document with an AcroForm.

Uses of InitializingBean in org.springframework.web.servlet.view.freemarker

Classes in org.springframework.web.servlet.view.freemarker that implement InitializingBean
`class` `FreeMarkerConfigurer` JavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
`class` `FreeMarkerView` View using the FreeMarker template engine.

Uses of InitializingBean in org.springframework.web.servlet.view.jasperreports

Classes in org.springframework.web.servlet.view.jasperreports that implement InitializingBean
`class` `AbstractJasperReportsSingleFormatView` Extends `AbstractJasperReportsView` to provide basic rendering logic for views that use a fixed format, e.g. always PDF or always HTML.
`class` `AbstractJasperReportsView` Base class for all JasperReports views.
`class` `ConfigurableJasperReportsView` Configurable JasperReports View, allowing to specify the JasperReports exporter to be specified through bean properties rather than through the view class name.
`class` `JasperReportsCsvView` Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in CSV format.
`class` `JasperReportsHtmlView` Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in HTML format.
`class` `JasperReportsMultiFormatView` Jasper Reports view class that allows for the actual rendering format to be specified at runtime using a parameter contained in the model.
`class` `JasperReportsPdfView` Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in PDF format.
`class` `JasperReportsXlsView` Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in XLS format.

Uses of InitializingBean in org.springframework.web.servlet.view.tiles

Classes in org.springframework.web.servlet.view.tiles that implement InitializingBean
`class` `TilesConfigurer` Helper class to configure Tiles 1.x for the Spring Framework.
`class` `TilesJstlView` Specialization of `TilesView` for JSTL pages, i.e.
`class` `TilesView` View implementation that retrieves a Tiles definition.

Uses of InitializingBean in org.springframework.web.servlet.view.velocity

Classes in org.springframework.web.servlet.view.velocity that implement InitializingBean
`class` `VelocityConfigurer` JavaBean to configure Velocity for web usage, via the "configLocation" and/or "velocityProperties" and/or "resourceLoaderPath" bean properties.
`class` `VelocityLayoutView` VelocityLayoutView emulates the functionality offered by Velocity's VelocityLayoutServlet to ease page composition from different templates.
`class` `VelocityToolboxView` `VelocityView` subclass which adds support for Velocity Tools toolboxes and Velocity Tools ViewTool callbacks / Velocity Tools 1.3 init methods.
`class` `VelocityView` View using the Velocity template engine.

Uses of InitializingBean in org.springframework.web.servlet.view.xslt

Classes in org.springframework.web.servlet.view.xslt that implement InitializingBean
`class` `XsltView` XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation.

Copyright © 2002-2008 The Spring Framework.