The Spring Framework

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.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 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.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 MBeanServers 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.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.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.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 superclass 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 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
          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 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.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 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 DerbyMaxValueIncrementer
          Class to increment 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
          Class to increment 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
          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 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
          Message listener container that builds on the ServerSessionPool SPI, creating JMS ServerSession instances through a pluggable ServerSessionFactory.
 class ServerSessionMessageListenerContainer102
          A subclass of ServerSessionMessageListenerContainer for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like ServerSessionMessageListenerContainer itself.
 

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.
 

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 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 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 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 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
          FactoryBeans 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 BurlapProxyFactoryBean
          FactoryBean for Burlap proxies.
 class BurlapServiceExporter
          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 HessianProxyFactoryBean
          FactoryBean for Hessian proxies.
 class HessianServiceExporter
          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
          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 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.
 

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 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 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.
 class WorkManagerTaskExecutor
          TaskExecutor implementation that delegates to a CommonJ WorkManager, implementing the WorkManager interface, which either needs to be specified as reference or through the JNDI 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 which delegates job execution to a specified (static or non-static) method.
 class SchedulerFactoryBean
          FactoryBean that sets up a Quartz Scheduler, manages its lifecycle as part of the Spring application context, and exposes the Scheduler 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.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/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.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.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.
 


The Spring Framework

Copyright © 2002-2007 The Spring Framework.