Uses of Interface org.springframework.beans.factory.InitializingBean (Spring Framework) - Spring Framework 1.2.9 API 文档英文版

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

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

Packages that use InitializingBean
org.springframework.beans.factory.config	SPI interfaces and configuration-related convenience classes for bean factories.
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.support	Provides generic support classes for JCA usage within Spring, mainly for local setup of a JCA ConnectionFactory.
org.springframework.jdbc.core	Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
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.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.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 proxy support for accessing MBean resources through standard Java interfaces.
org.springframework.jmx.export	This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
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.hibernate	Package providing integration of Hibernate 2.1 with Spring concepts.
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.ojb	Package providing integration of Apache OJB with Spring concepts.
org.springframework.orm.ojb.support	Classes supporting the org.springframework.orm.ojb 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.rmi	Remoting classes for conventional RMI and transparent remoting via RMI invokers.
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 1.3+ 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.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.servlet.mvc	Standard controller implementations for the 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.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.

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
          FactoryBean which returns a value which is an ObjectFactory that returns a bean from the 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
          FactoryBean 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 the Spring BeanFactory underneath.

class SetFactoryBean
          Simple factory for shared Set instances.

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` FactoryBean which returns a value which is an ObjectFactory that returns a bean from the 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` FactoryBean 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 the Spring BeanFactory underneath.`
`class`	`SetFactoryBean` Simple factory for shared Set instances.

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 object, representing a cache region.

class EhCacheManagerFactoryBean
FactoryBean that exposes a EHCache CacheManager singleton, configured from a specified config location.

Classes in org.springframework.cache.ehcache that implement InitializingBean
`class`	`EhCacheFactoryBean` FactoryBean that creates a named EHCache Cache object, representing a cache region.
`class`	`EhCacheManagerFactoryBean` FactoryBean that exposes a EHCache CacheManager singleton, 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 (typically an ApplicationContext), after each successful method invocation.

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

Uses of InitializingBean in org.springframework.context.support

Classes in org.springframework.context.support that implement InitializingBean

class ResourceMapFactoryBean
FactoryBean that creates a Map with String keys and Resource values from properties, interpreting passed-in String values as resource locations.

Classes in org.springframework.context.support that implement InitializingBean
`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.

Classes in org.springframework.dao.support that implement InitializingBean
`class`	`DaoSupport` Generic base class for DAOs, defining template methods for DAO initialization.

Uses of InitializingBean in org.springframework.ejb.access

Classes in org.springframework.ejb.access that implement InitializingBean

class AbstractRemoteSlsbInvokerInterceptor
          Superclass for interceptors proxying remote Stateless Session Beans.

class AbstractSlsbInvokerInterceptor
          Superclass 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.

Classes in org.springframework.ejb.access that implement InitializingBean
`class`	`AbstractRemoteSlsbInvokerInterceptor` Superclass for interceptors proxying remote Stateless Session Beans.
`class`	`AbstractSlsbInvokerInterceptor` Superclass 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 performs local transactions on a single CCI ConnectionFactory.

class ConnectionSpecConnectionFactoryAdapter
          An adapter for a target ConnectionFacory, applying the given ConnectionSpec to every standard getConnection() call, that is, implicitly invoking getConnection(ConnectionSpec) on the target.

class DelegatingConnectionFactory
          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.

Classes in org.springframework.jca.cci.connection that implement InitializingBean
`class`	`CciLocalTransactionManager` PlatformTransactionManager implementation that performs local transactions on a single CCI ConnectionFactory.
`class`	`ConnectionSpecConnectionFactoryAdapter` An adapter for a target ConnectionFacory, applying the given ConnectionSpec to every standard `getConnection()` call, that is, implicitly invoking `getConnection(ConnectionSpec)` on the target.
`class`	`DelegatingConnectionFactory` `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 data access objects.

Classes in org.springframework.jca.cci.core.support that implement InitializingBean
`class`	`CciDaoSupport` Convenient super class for CCI 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.

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

Classes in org.springframework.jca.support that implement InitializingBean

class LocalConnectionFactoryBean
This FactoryBean creates a local JCA connection factory in "non-managed" mode (as defined by the Java Connector Architecture specification).

Classes in org.springframework.jca.support that implement InitializingBean
`class`	`LocalConnectionFactoryBean` This FactoryBean creates a local JCA connection factory in "non-managed" mode (as defined by the Java Connector Architecture specification).

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.

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

Classes in org.springframework.jdbc.core.support that implement InitializingBean

class JdbcDaoSupport
Convenient super class for JDBC data access objects.

Classes in org.springframework.jdbc.core.support that implement InitializingBean
`class`	`JdbcDaoSupport` Convenient super class for JDBC 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
          DataSource implementation that delegates all calls to a given target DataSource.

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 DataSource, applying the given user credentials to every standard getConnection() call, that is, implicitly invoking getConnection(username, password) on the target.

Classes in org.springframework.jdbc.datasource that implement InitializingBean
`class`	`DataSourceTransactionManager` `PlatformTransactionManager` implementation for a single JDBC `DataSource`.
`class`	`DelegatingDataSource` DataSource implementation that delegates all calls to a given target DataSource.
`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 DataSource, applying the given user credentials to every standard `getConnection()` call, that is, implicitly invoking `getConnection(username, password)` on the target.

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 multithreaded, reusable object representing a query, update or stored procedure.

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
          RdbmsOperation using a JdbcTemplate and representing a SQL-based operation such as a query or update, as opposed to a stored procedure.

class SqlQuery
          Reusable object to represent a SQL query.

class SqlUpdate
          RdbmsOperation subclass 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.

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 multithreaded, reusable object representing a query, update or stored procedure.
`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` RdbmsOperation using a JdbcTemplate and representing a SQL-based operation such as a query or update, as opposed to a stored procedure.
`class`	`SqlQuery` Reusable object to represent a SQL query.
`class`	`SqlUpdate` RdbmsOperation subclass 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 like DataSource and exception translator.

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 like DataSource and exception translator.

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

Classes in org.springframework.jdbc.support.incrementer that implement InitializingBean

class AbstractDataFieldMaxValueIncrementer
          Implementation of DataFieldMaxValueIncrementer that delegates to a single getNextKey template method that returns a long.

class AbstractSequenceMaxValueIncrementer
          Abstract base class for incrementers that use a database sequence.

class DB2SequenceMaxValueIncrementer
          DataFieldMaxValueIncrementer that retrieves the next value of a given DB2 sequence.

class HsqlMaxValueIncrementer
          Class to increment maximum value of a given HSQL table with the equivalent of an auto-increment column.

class MySQLMaxValueIncrementer
          Class to increment 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
          Class to retrieve the next value of a given PostgreSQL Sequence.

Classes in org.springframework.jdbc.support.incrementer that implement InitializingBean
`class`	`AbstractDataFieldMaxValueIncrementer` Implementation of DataFieldMaxValueIncrementer that delegates to a single getNextKey template method that returns a long.
`class`	`AbstractSequenceMaxValueIncrementer` Abstract base class for incrementers that use a database sequence.
`class`	`DB2SequenceMaxValueIncrementer` DataFieldMaxValueIncrementer that retrieves the next value of a given DB2 sequence.
`class`	`HsqlMaxValueIncrementer` Class to increment maximum value of a given HSQL table with the equivalent of an auto-increment column.
`class`	`MySQLMaxValueIncrementer` Class to increment 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` Class to retrieve the next value of a given PostgreSQL Sequence.

Uses of InitializingBean in org.springframework.jms.connection

Classes in org.springframework.jms.connection that implement InitializingBean

class SingleConnectionFactory102
A subclass of SingleConnectionFactory that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by SingleConnectionFactory itself.

Classes in org.springframework.jms.connection that implement InitializingBean
`class`	`SingleConnectionFactory102` A subclass of SingleConnectionFactory that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by SingleConnectionFactory itself.

Uses of InitializingBean in org.springframework.jms.core

Classes in org.springframework.jms.core that implement InitializingBean

class JmsTemplate
Helper class that simplifies JMS access code.

class JmsTemplate102
A subclass of JmsTemplate that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by JmsTemplate itself.

Classes in org.springframework.jms.core that implement InitializingBean
`class`	`JmsTemplate` Helper class that simplifies JMS access code.
`class`	`JmsTemplate102` A subclass of JmsTemplate that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by 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.

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

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

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.

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

Classes in org.springframework.jmx.access that implement InitializingBean
`class`	`MBeanClientInterceptor` `MethodInterceptor` implementation 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.

Uses of InitializingBean in org.springframework.jmx.export

Classes in org.springframework.jmx.export that implement InitializingBean

class MBeanExporter
A bean that allows for any Spring-managed bean to be exposed to a JMX MBeanServer, without the need to define any JMX-specific information in the bean classes.

Classes in org.springframework.jmx.export that implement InitializingBean
`class`	`MBeanExporter` A bean that allows for any Spring-managed bean to be exposed to a JMX `MBeanServer`, without the need to define any JMX-specific information in the bean classes.

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

Classes in org.springframework.jmx.export.assembler that implement InitializingBean

class MetadataMBeanInfoAssembler
Implementation of MBeanInfoAssembler 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.

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 implementation that creates an 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 the WebLogic MBeanServer instance through a WebLogic MBeanHome obtained via a JNDI lookup.

class WebLogicMBeanServerFactoryBean
          FactoryBean that obtains a specified WebLogic MBeanServer instance through WebLogic's proprietary Helper / MBeanHome API, which is available on WebLogic 6.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.hibernate

Classes in org.springframework.orm.hibernate that implement InitializingBean

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, and converts checked HibernateExceptions into unchecked DataAccessExceptions, following the org.springframework.dao exception hierarchy.

class HibernateTransactionManager
          PlatformTransactionManager implementation for a single Hibernate SessionFactory.

class LocalSessionFactoryBean
          FactoryBean that creates a local Hibernate SessionFactory instance.

Uses of InitializingBean in org.springframework.orm.hibernate3

Classes in org.springframework.orm.hibernate3 that implement InitializingBean

class FilterDefinitionFactoryBean
Convenient FactoryBean for defining Hibernate FilterDefinitions.

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 Hibernate3, 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 HandlerInterceptor 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 Database Layer SqlMapClient as singleton in the current bean factory, possibly for use with SqlMapClientTemplate.

class SqlMapClientTemplate
          Helper class that simplifies data access via the SqlMapClient API of iBATIS SQL Maps, and converts checked SQLExceptions into unchecked DataAccessExceptions, following the org.springframework.dao exception hierarchy.

class SqlMapFactoryBean
          FactoryBean that creates an iBATIS Database Layer SqlMap as singleton in the current bean factory, possibly for use with SqlMapTemplate.

class SqlMapTemplate
          Helper class that simplifies data access via the MappedStatement API of iBATIS SQL Maps, and converts 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.

class SqlMapDaoSupport
Convenient super class for iBATIS SqlMap 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 like 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 local JDO EntityManagerFactory instance.

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

Classes in org.springframework.orm.ojb that implement InitializingBean

class OjbAccessor
Base class for OJB-accessing classes, defining common properties like PBKey.

class PersistenceBrokerTemplate
Helper class that simplifies OJB PersistenceBroker data access code, and converts PersistenceBrokerExceptions into Spring DataAccessExceptions, following the org.springframework.dao exception hierarchy.

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

Classes in org.springframework.orm.ojb.support that implement InitializingBean

class PersistenceBrokerDaoSupport
Convenient super class for OJB PersistenceBroker data access objects.

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 like 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
          Interceptor for accessing a Burlap service.

class BurlapProxyFactoryBean
          Factory bean for Burlap proxies.

class BurlapServiceExporter
          Web controller that exports the specified service bean as Burlap service endpoint, accessible via a Burlap proxy.

class CauchoRemoteAccessor
          Common base class for Hessian/Burlap accessors (HessianClientInterceptor and BurlapClientInterceptor), factoring out common properties.

class HessianClientInterceptor
          Interceptor for accessing a Hessian service.

class HessianProxyFactoryBean
          Factory bean for Hessian proxies.

class HessianServiceExporter
          Web controller 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 HttpInvokerProxyFactoryBean
Factory bean for HTTP invoker proxies.

class HttpInvokerServiceExporter
Web controller 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
          Interceptor 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.rmi

Classes in org.springframework.remoting.rmi that implement InitializingBean

class JndiRmiClientInterceptor
          Interceptor 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 RmiClientInterceptor
          Interceptor for accessing conventional RMI services or RMI invokers.

class RmiProxyFactoryBean
          Factory bean 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.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 that delegates job execution to a specified (static or non-static) method.

class SchedulerFactoryBean
          FactoryBean that sets up a Quartz Scheduler and exposes it for bean references.

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 JDK 1.3+ Timer and exposes it for bean references.

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 TransactionAspectSupport
          Superclass for transactional aspects, such as the AOP Alliance-compatible TransactionInterceptor, or an AspectJ aspect.

class TransactionInterceptor
          AOP Alliance MethodInterceptor providing declarative transaction management using the common Spring transaction infrastructure.

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 WebLogicJtaTransactionManager
Special JtaTransactionManager version for BEA WebLogic (7.0, 8.1 and higher).

Uses of InitializingBean in org.springframework.transaction.support

Classes in org.springframework.transaction.support that implement InitializingBean

class TransactionTemplate
Helper 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.filter

Classes in org.springframework.web.filter that implement InitializingBean

class AbstractRequestLoggingFilter
          Base class for Filters that perform logging operations before and after a request is processed.

class CharacterEncodingFilter
          Servlet 2.3 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 javax.servlet.Filter that treats its config parameters 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 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.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
          AbstractTemplateView provides 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, exposing all model attributes as HTTP query parameters.

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

class VelocityView
          View using the Velocity template engine.