|
The Spring Framework | |||||||||
PREV NEXT | FRAMES NO FRAMES |
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.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.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.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.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.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.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 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.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 |
ResourceFactoryBean
FactoryBean for Resource descriptors,
exposing a Resource object for a specific resource location. |
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.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.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 |
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 |
JmsTransactionManager
PlatformTransactionManager implementation
for a single JMS ConnectionFactory . |
class |
JmsTransactionManager102
A subclass of JmsTransactionManager that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by JmsTransactionManager itself. |
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. |
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 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. |
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 that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by 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 that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by SimpleMessageListenerContainer itself. |
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 JMS ServerSessionPool SPI, creating JMS ServerSessions through a pluggable ServerSessionFactory. |
class |
ServerSessionMessageListenerContainer102
A subclass of ServerSessionMessageListenerContainer that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by ServerSessionMessageListenerContainer itself. |
Uses of InitializingBean in org.springframework.jms.remoting |
---|
Classes in org.springframework.jms.remoting that implement InitializingBean | |
---|---|
class |
JmsInvokerClientInterceptor
Interceptor 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 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
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.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 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 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.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
Hibernate SessionFactory . |
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. |
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 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
Interceptor 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
Interceptor 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
Interceptor 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
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
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
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 |
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). |
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 Filter s that perform logging operations before and after a
request is processed. |
class |
CharacterEncodingFilter
Servlet 2.3/2.4 Filter that allows one to specify a character encoding for requests. |
class |
CommonsRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log. |
class |
DelegatingFilterProxy
Proxy for a standard Servlet 2.3 Filter, delegating to a Spring-managed bean that implements the Filter interface. |
class |
GenericFilterBean
Simple base implementation of Filter which treats
its config parameters (init-param entries within the
filter tag in web.xml ) as bean properties. |
class |
Log4jNestedDiagnosticContextFilter
Request logging filter that adds the request log message to the Log4J nested diagnostic context (NDC) before the request is processed, removing it again after the request is processed. |
class |
OncePerRequestFilter
Filter base class that guarantees to be just executed once per request, on any servlet container. |
class |
RequestContextFilter
Servlet 2.3+ filter that exposes the request to the current thread, through both LocaleContextHolder and
RequestContextHolder . |
class |
ServletContextRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log. |
Uses of InitializingBean in org.springframework.web.multipart.support |
---|
Classes in org.springframework.web.multipart.support that implement InitializingBean | |
---|---|
class |
MultipartFilter
Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver. |
Uses of InitializingBean in org.springframework.web.portlet.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
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 |
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 for the Spring Framework. |
class |
TilesJstlView
Specialization of TilesView for JSTL pages; Tiles pages that use the JSP Standard Tag Library. |
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 | |||||||||
PREV NEXT | FRAMES NO FRAMES |