| 
 | ||||||||||
| 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.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.corepackage. | 
| org.springframework.jca.cci.object | The classes in this package represent EIS operations as threadsafe, reusable objects. | 
| org.springframework.jca.endpoint | This package provides a facility for generic JCA message endpoint management. | 
| org.springframework.jca.support | Provides generic support classes for JCA usage within Spring, mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory. | 
| org.springframework.jca.work | Convenience classes for scheduling based on the JCA 1.5 WorkManager facility, as supported within JCA 1.5 ResourceAdapters. | 
| org.springframework.jca.work.glassfish | Convenience package for obtaining a GlassFish JCA WorkManager for use in web applications. | 
| org.springframework.jca.work.jboss | Convenience package for obtaining a JBoss JCA WorkManager for use in web applications. | 
| org.springframework.jdbc.core | Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects. | 
| org.springframework.jdbc.core.namedparam | JdbcTemplate variant with named parameter support. | 
| org.springframework.jdbc.core.simple | Simplification layer over JdbcTemplate for Java 5 and above. | 
| org.springframework.jdbc.core.support | Classes supporting the org.springframework.jdbc.corepackage. | 
| org.springframework.jdbc.datasource | Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations. | 
| org.springframework.jdbc.datasource.lookup | Provides a strategy for looking up JDBC DataSources by name. | 
| org.springframework.jdbc.object | The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects. | 
| org.springframework.jdbc.support | Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages. | 
| org.springframework.jdbc.support.incrementer | Provides a support framework for incrementing database table values via sequences, with implementations for various databases. | 
| org.springframework.jms.connection | Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter. | 
| org.springframework.jms.core | Core package of the JMS support. | 
| org.springframework.jms.core.support | Classes supporting the org.springframework.jms.core package. | 
| org.springframework.jms.listener | This package contains the base message listener container facility. | 
| org.springframework.jms.listener.endpoint | This package provides JCA-based endpoint management for JMS message listeners. | 
| org.springframework.jms.listener.serversession | This package contains the ServerSessionMessageListenerContainer implementation, based on the standard JMS ServerSessionPool API. | 
| org.springframework.jms.remoting | Remoting classes for transparent Java-to-Java remoting via a JMS provider. | 
| org.springframework.jms.support | This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate. | 
| org.springframework.jms.support.destination | Support classes for Spring's JMS framework. | 
| org.springframework.jmx.access | Provides support for accessing remote MBean resources. | 
| org.springframework.jmx.export | This package provides declarative creation and registration of Spring-managed beans as JMX MBeans. | 
| org.springframework.jmx.export.annotation | JDK 1.5+ annotations for MBean exposure. | 
| org.springframework.jmx.export.assembler | Provides a strategy for MBeanInfo assembly. | 
| org.springframework.jmx.export.metadata | Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner. | 
| org.springframework.jmx.export.naming | Provides a strategy for ObjectName creation. | 
| org.springframework.jmx.support | Contains support classes for connecting to local and remote MBeanServers
and for exposing anMBeanServerto 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.hibernate3package. | 
| 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.ibatispackage. | 
| 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.jdopackage. | 
| 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.jpapackage. | 
| org.springframework.orm.toplink | Package providing integration of Oracle TopLink with Spring concepts. | 
| org.springframework.orm.toplink.support | Classes supporting the org.springframework.orm.toplinkpackage. | 
| org.springframework.remoting.caucho | This package provides remoting classes for Caucho's Hessian and Burlap protocols: a proxy factory for accessing Hessian/Burlap services, and an exporter for making beans available to Hessian/Burlap clients. | 
| org.springframework.remoting.httpinvoker | Remoting classes for transparent Java-to-Java remoting via HTTP invokers. | 
| org.springframework.remoting.jaxrpc | Remoting classes for Web Services via JAX-RPC. | 
| org.springframework.remoting.jaxws | Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC), as included in Java 6 and Java EE 5. | 
| org.springframework.remoting.rmi | Remoting classes for conventional RMI and transparent remoting via RMI invokers. | 
| org.springframework.remoting.support | Generic support classes for remoting implementations. | 
| org.springframework.scheduling.backportconcurrent | Scheduling convenience classes for the JSR-166 backport Executor mechanism, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as bean in a Spring context. | 
| org.springframework.scheduling.commonj | Convenience classes for scheduling based on the CommonJ WorkManager/TimerManager facility, as supported by IBM WebSphere 6.0+ and BEA WebLogic 9.0+. | 
| org.springframework.scheduling.quartz | Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context. | 
| org.springframework.scheduling.support | Generic support classes for scheduling. | 
| org.springframework.scheduling.timer | Scheduling convenience classes for the JDK Timer, allowing to set up Timers and ScheduledTimerTasks as beans in a Spring context. | 
| org.springframework.transaction.interceptor | AOP-based solution for declarative transaction demarcation. | 
| org.springframework.transaction.jta | Transaction SPI implementation for JTA. | 
| org.springframework.transaction.support | Support classes for the org.springframework.transaction package. | 
| org.springframework.ui.freemarker | Support classes for setting up FreeMarker within a Spring application context. | 
| org.springframework.ui.velocity | Support classes for setting up Velocity within a Spring application context. | 
| org.springframework.web.context.support | Classes supporting the org.springframework.web.contextpackage,
such as WebApplicationContext implementations and various utility classes. | 
| org.springframework.web.filter | Provides generic filter base classes allowing for bean-style configuration. | 
| org.springframework.web.multipart.support | Support classes for the multipart resolution framework. | 
| org.springframework.web.portlet.context | Support for Spring's application context concept in a portlet environment, including ApplicationContext implementations and various utility classes. | 
| org.springframework.web.portlet.mvc | Standard controller implementations for the portlet MVC framework that comes with Spring. | 
| org.springframework.web.servlet.mvc | Standard controller implementations for the servlet MVC framework that comes with Spring. | 
| org.springframework.web.servlet.mvc.multiaction | Package allowing MVC Controller implementations to handle requests at method rather than class level. | 
| org.springframework.web.servlet.view | Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations. | 
| org.springframework.web.servlet.view.document | Support classes for document generation, providing View implementations for PDF and Excel. | 
| org.springframework.web.servlet.view.freemarker | Support classes for the integration of FreeMarker as Spring web view technology. | 
| org.springframework.web.servlet.view.jasperreports | Support classes for the integration of JasperReports as Spring web view technology. | 
| org.springframework.web.servlet.view.tiles | Support classes for the integration of Tiles (included in Struts) as Spring web view technology. | 
| org.springframework.web.servlet.view.velocity | Support classes for the integration of Velocity as Spring web view technology. | 
| org.springframework.web.servlet.view.xslt | Support classes for XSLT, providing a View implementation for XSLT stylesheets. | 
| Uses of InitializingBean in org.springframework.aop.framework | 
|---|
| Classes in org.springframework.aop.framework that implement InitializingBean | |
|---|---|
|  class | AbstractSingletonProxyFactoryBeanConvenient 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 | AbstractFactoryBeanSimple template superclass for FactoryBeanimplementations that
 creates a singleton or a prototype object, depending on a flag. | 
|  class | CommonsLogFactoryBeanFactory bean for commons-logging Loginstances. | 
|  class | FieldRetrievingFactoryBeanFactoryBean which retrieves a static or non-static field value. | 
|  class | ListFactoryBeanSimple factory for shared List instances. | 
|  class | MapFactoryBeanSimple factory for shared Map instances. | 
|  class | MethodInvokingFactoryBeanFactoryBean which returns a value which is the result of a static or instance method invocation. | 
|  class | ObjectFactoryCreatingFactoryBeanA FactoryBeanimplementation that
 returns a value which is anObjectFactorythat in turn returns a bean sourced from aBeanFactory. | 
|  class | PreferencesPlaceholderConfigurerSubclass of PropertyPlaceholderConfigurer that supports JDK 1.4's Preferences API ( java.util.prefs). | 
|  class | PropertiesFactoryBeanAllows for making a properties file from a classpath location available as Properties instance in a bean factory. | 
|  class | ServiceLocatorFactoryBeanA FactoryBeanimplementation that
 takes an interface which must have one or more methods with
 the signaturesMyType xxx()orMyType xxx(MyIdType id)(typically,MyService getService()orMyService getService(String id))
 and creates a dynamic proxy which implements that interface, delegating to an
 underlyingBeanFactory. | 
|  class | SetFactoryBeanSimple 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 | AbstractServiceLoaderBasedFactoryBeanAbstract base class for FactoryBeans operating on the JDK 1.6 ServiceLoaderfacility. | 
|  class | ServiceFactoryBeanFactoryBeanthat exposes the
 'primary' service for the configured service class, obtained through
 the JDK 1.6ServiceLoaderfacility. | 
|  class | ServiceListFactoryBeanFactoryBeanthat exposes all
 services for the configured service class, represented as a List of service objects,
 obtained through the JDK 1.6ServiceLoaderfacility. | 
|  class | ServiceLoaderFactoryBeanFactoryBeanthat exposes the
 JDK 1.6ServiceLoaderfor the configured service class. | 
| Uses of InitializingBean in org.springframework.beans.factory.wiring | 
|---|
| Classes in org.springframework.beans.factory.wiring that implement InitializingBean | |
|---|---|
|  class | BeanConfigurerSupportConvenient base class for configurers that can perform Dependency Injection on objects (however they may be created). | 
| Uses of InitializingBean in org.springframework.cache.ehcache | 
|---|
| Classes in org.springframework.cache.ehcache that implement InitializingBean | |
|---|---|
|  class | EhCacheFactoryBeanFactoryBean that creates a named EHCache Cacheinstance
 (or a decorator that implements theEhcacheinterface),
 representing a cache region within an EHCacheCacheManager. | 
|  class | EhCacheManagerFactoryBeanFactoryBean that exposes an EHCache CacheManagerinstance
 (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 | EventPublicationInterceptorInterceptorthat publishes anApplicationEventto allApplicationListenersregistered with anApplicationEventPublisherafter each
 successful method invocation. | 
| Uses of InitializingBean in org.springframework.context.support | 
|---|
| Classes in org.springframework.context.support that implement InitializingBean | |
|---|---|
|  class | AbstractRefreshableConfigApplicationContextAbstractRefreshableApplicationContextsubclass that adds common handling
 of specified config locations. | 
|  class | AbstractXmlApplicationContextConvenient base class for ApplicationContextimplementations, drawing configuration from XML documents containing bean definitions
 understood by anXmlBeanDefinitionReader. | 
|  class | ClassPathXmlApplicationContextStandalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g. | 
|  class | FileSystemXmlApplicationContextStandalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g. | 
|  class | ResourceMapFactoryBeanFactoryBean 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 | DaoSupportGeneric base class for DAOs, defining template methods for DAO initialization. | 
|  class | PersistenceExceptionTranslationInterceptorAOP 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 | AbstractRemoteSlsbInvokerInterceptorBase class for interceptors proxying remote Stateless Session Beans. | 
|  class | AbstractSlsbInvokerInterceptorBase class for AOP interceptors invoking local or remote Stateless Session Beans. | 
|  class | LocalSlsbInvokerInterceptorInvoker for a local Stateless Session Bean. | 
|  class | LocalStatelessSessionProxyFactoryBeanConvenient factory for local Stateless Session Bean (SLSB) proxies. | 
|  class | SimpleRemoteSlsbInvokerInterceptorBasic invoker for a remote Stateless Session Bean. | 
|  class | SimpleRemoteStatelessSessionProxyFactoryBeanConvenient 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 | CciLocalTransactionManagerPlatformTransactionManagerimplementation
 that manages local transactions for a single CCI ConnectionFactory. | 
|  class | ConnectionSpecConnectionFactoryAdapterAn adapter for a target CCI ConnectionFactory,
 applying the given ConnectionSpec to every standardgetConnection()call, that is, implicitly invokinggetConnection(ConnectionSpec)on the target. | 
|  class | DelegatingConnectionFactoryCCI ConnectionFactoryimplementation that delegates all calls
 to a given targetConnectionFactory. | 
|  class | SingleConnectionFactoryA CCI ConnectionFactory adapter that returns the same Connection on all getConnectioncalls, and ignores calls toConnection.close(). | 
|  class | TransactionAwareConnectionFactoryProxyProxy 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 | CciDaoSupportConvenient 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 | EisOperationBase class for EIS operation objects that work with the CCI API. | 
|  class | MappingCommAreaOperationEIS operation object for access to COMMAREA records. | 
|  class | MappingRecordOperationEIS operation object that expects mapped input and output objects, converting to and from CCI Records. | 
|  class | SimpleRecordOperationEIS 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 | GenericMessageEndpointManagerGeneric 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 | LocalConnectionFactoryBeanFactoryBeanthat creates
 a local JCA connection factory in "non-managed" mode (as defined by the
 Java Connector Architecture specification). | 
|  class | ResourceAdapterFactoryBeanFactoryBeanthat bootstraps
 the specified JCA 1.5ResourceAdapter,
 starting it with a localBootstrapContextand exposing it for bean references. | 
| Uses of InitializingBean in org.springframework.jca.work | 
|---|
| Classes in org.springframework.jca.work that implement InitializingBean | |
|---|---|
|  class | WorkManagerTaskExecutorTaskExecutorimplementation
 that delegates to a JCA 1.5 WorkManager, implementing theWorkManagerinterface. | 
| Uses of InitializingBean in org.springframework.jca.work.glassfish | 
|---|
| Classes in org.springframework.jca.work.glassfish that implement InitializingBean | |
|---|---|
|  class | GlassFishWorkManagerTaskExecutorSpring TaskExecutor adapter for the GlassFish JCA WorkManager. | 
| Uses of InitializingBean in org.springframework.jca.work.jboss | 
|---|
| Classes in org.springframework.jca.work.jboss that implement InitializingBean | |
|---|---|
|  class | JBossWorkManagerTaskExecutorSpring TaskExecutor adapter for the JBoss JCA WorkManager. | 
| Uses of InitializingBean in org.springframework.jdbc.core | 
|---|
| Classes in org.springframework.jdbc.core that implement InitializingBean | |
|---|---|
|  class | JdbcTemplateThis 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 | NamedParameterJdbcDaoSupportExtension 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 | SimpleJdbcDaoSupportExtension of JdbcDaoSupportthat exposes aSimpleJdbcTemplateas well. | 
| Uses of InitializingBean in org.springframework.jdbc.core.support | 
|---|
| Classes in org.springframework.jdbc.core.support that implement InitializingBean | |
|---|---|
|  class | JdbcDaoSupportConvenient 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 | DataSourceTransactionManagerPlatformTransactionManagerimplementation for a single JDBCDataSource. | 
|  class | DelegatingDataSourceJDBC DataSourceimplementation that delegates all calls
 to a given targetDataSource. | 
|  class | IsolationLevelDataSourceAdapterAn adapter for a target DataSource, applying the current
 Spring transaction's isolation level (and potentially specified user credentials)
 to everygetConnectioncall. | 
|  class | LazyConnectionDataSourceProxyProxy for a target DataSource, fetching actual JDBC Connections lazily, i.e. not until first creation of a Statement. | 
|  class | TransactionAwareDataSourceProxyProxy for a target JDBC DataSource, adding awareness of
 Spring-managed transactions. | 
|  class | UserCredentialsDataSourceAdapterAn adapter for a target JDBC DataSource, applying the specified
 user credentials to every standardgetConnection()call, implicitly
 invokinggetConnection(username, password)on the target. | 
|  class | WebSphereDataSourceAdapterDataSourceimplementation that delegates all calls to a WebSphere
 targetDataSource, 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 | AbstractRoutingDataSourceAbstract DataSourceimplementation that routesAbstractRoutingDataSource.getConnection()calls to one of various target DataSources based on a lookup key. | 
|  class | IsolationLevelDataSourceRouterDataSource 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 | BatchSqlUpdateSqlUpdate subclass that performs batch update operations. | 
|  class | MappingSqlQueryReusable 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 | MappingSqlQueryWithParametersReusable 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 | RdbmsOperationAn "RDBMS operation" is a multi-threaded, reusable object representing a query, update, or stored procedure call. | 
|  class | SqlCallRdbmsOperation using a JdbcTemplate and representing a SQL-based call such as a stored procedure or a stored function. | 
|  class | SqlFunctionSQL "function" wrapper for a query that returns a single row of results. | 
|  class | SqlOperationOperation object representing a SQL-based operation such as a query or update, as opposed to a stored procedure. | 
|  class | SqlQueryReusable operation object representing a SQL query. | 
|  class | SqlUpdateReusable operation object representing a SQL update. | 
|  class | StoredProcedureSuperclass for object abstractions of RDBMS stored procedures. | 
|  class | UpdatableSqlQueryReusable 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 | DatabaseStartupValidatorBean that checks if a database has already started up. | 
|  class | JdbcAccessorBase class for JdbcTemplateand
 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 | AbstractColumnMaxValueIncrementerAbstract base class for DataFieldMaxValueIncrementerimplementations that use
 a column in a custom sequence table. | 
|  class | AbstractDataFieldMaxValueIncrementerBase implementation of DataFieldMaxValueIncrementerthat delegates
 to a singleAbstractDataFieldMaxValueIncrementer.getNextKey()template method that returns along. | 
|  class | AbstractSequenceMaxValueIncrementerAbstract base class for DataFieldMaxValueIncrementerimplementations that use
 a database sequence. | 
|  class | DB2MainframeSequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given sequence
 on DB2/390 or DB2/400. | 
|  class | DB2SequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given sequence
 on DB2 UDB (for Unix and Windows). | 
|  class | DerbyMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given Derby table
 with the equivalent of an auto-increment column. | 
|  class | H2SequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given H2 Database sequence. | 
|  class | HsqlMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given HSQL table
 with the equivalent of an auto-increment column. | 
|  class | HsqlSequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given HSQL sequence. | 
|  class | MySQLMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given MySQL table
 with the equivalent of an auto-increment column. | 
|  class | OracleSequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given Oracle sequence. | 
|  class | PostgreSQLSequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given PostgreSQL sequence. | 
|  class | SqlServerMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given SQL Server table
 with the equivalent of an auto-increment column. | 
|  class | SybaseMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given SQL Server table
 with the equivalent of an auto-increment column. | 
| Uses of InitializingBean in org.springframework.jms.connection | 
|---|
| Classes in org.springframework.jms.connection that implement InitializingBean | |
|---|---|
|  class | CachingConnectionFactorySingleConnectionFactorysubclass that addsSessioncaching as wellMessageProducercaching. | 
|  class | JmsTransactionManagerPlatformTransactionManagerimplementation
 for a single JMSConnectionFactory. | 
|  class | JmsTransactionManager102A subclass of JmsTransactionManagerfor the JMS 1.0.2 specification,
 not relying on JMS 1.1 methods like JmsTransactionManager itself. | 
|  class | SingleConnectionFactory102A subclass of SingleConnectionFactoryfor the JMS 1.0.2 specification,
 not relying on JMS 1.1 methods like SingleConnectionFactory itself. | 
|  class | UserCredentialsConnectionFactoryAdapterAn adapter for a target JMS ConnectionFactory, applying the
 given user credentials to every standardcreateConnection()call,
 that is, implicitly invokingcreateConnection(username, password)on the target. | 
| Uses of InitializingBean in org.springframework.jms.core | 
|---|
| Classes in org.springframework.jms.core that implement InitializingBean | |
|---|---|
|  class | JmsTemplateHelper class that simplifies synchronous JMS access code. | 
|  class | JmsTemplate102A subclass of JmsTemplatefor 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 | JmsGatewaySupportConvenient 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 | AbstractJmsListeningContainerCommon base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt). | 
|  class | AbstractMessageListenerContainerAbstract base class for message listener containers. | 
|  class | AbstractPollingMessageListenerContainerBase class for listener container implementations which are based on polling. | 
|  class | DefaultMessageListenerContainerMessage 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 | DefaultMessageListenerContainer102A subclass of DefaultMessageListenerContainerfor the JMS 1.0.2 specification,
 not relying on JMS 1.1 methods like SimpleMessageListenerContainer itself. | 
|  class | SimpleMessageListenerContainerMessage listener container that uses the plain JMS client API's MessageConsumer.setMessageListener()method to
 create concurrent MessageConsumers for the specified listeners. | 
|  class | SimpleMessageListenerContainer102A subclass of SimpleMessageListenerContainerfor 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 | JmsMessageEndpointManagerExtension 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 | ServerSessionMessageListenerContainerDeprecated. as of Spring 2.5, in favor of DefaultMessageListenerContainer and JmsMessageEndpointManager. To be removed in Spring 3.0. | 
|  class | ServerSessionMessageListenerContainer102Deprecated. as of Spring 2.5, in favor of DefaultMessageListenerContainer and JmsMessageEndpointManager. To be removed in Spring 3.0. | 
| Uses of InitializingBean in org.springframework.jms.remoting | 
|---|
| Classes in org.springframework.jms.remoting that implement InitializingBean | |
|---|---|
|  class | JmsInvokerClientInterceptorMethodInterceptorfor accessing a
 JMS-based remote service. | 
|  class | JmsInvokerProxyFactoryBeanFactoryBean for JMS invoker proxies. | 
|  class | JmsInvokerServiceExporterJMS 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 | JmsAccessorBase class for JmsTemplateand other
 JMS-accessing gateway helpers, defining common properties such as the
 JMSConnectionFactoryto operate on. | 
| Uses of InitializingBean in org.springframework.jms.support.destination | 
|---|
| Classes in org.springframework.jms.support.destination that implement InitializingBean | |
|---|---|
|  class | JmsDestinationAccessorBase class for JmsTemplateand other
 JMS-accessing gateway helpers, adding destination-related properties toJmsAccessor'scommon properties. | 
| Uses of InitializingBean in org.springframework.jmx.access | 
|---|
| Classes in org.springframework.jmx.access that implement InitializingBean | |
|---|---|
|  class | MBeanClientInterceptorMethodInterceptorthat routes calls to an
 MBean running on the suppliedMBeanServerConnection. | 
|  class | MBeanProxyFactoryBeanCreates a proxy to a managed resource running either locally or remotely. | 
|  class | NotificationListenerRegistrarRegistrar object that associates a specific NotificationListenerwith one or more MBeans in anMBeanServer(typically via aMBeanServerConnection). | 
| Uses of InitializingBean in org.springframework.jmx.export | 
|---|
| Classes in org.springframework.jmx.export that implement InitializingBean | |
|---|---|
|  class | MBeanExporterJMX 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 | NotificationListenerBeanHelper class that aggregates a NotificationListener,
 aNotificationFilter, 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 | AnnotationMBeanExporterConvenient 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 | InterfaceBasedMBeanInfoAssemblerSubclass of AbstractReflectiveMBeanInfoAssemblerthat allows for
 the management interface of a bean to be defined using arbitrary interfaces. | 
|  class | MetadataMBeanInfoAssemblerImplementation of the MBeanInfoAssemblerinterface 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 | AttributesJmxAttributeSourceImplementation of the JmxAttributeSourceinterface that
 reads metadata via Spring'sAttributesabstraction. | 
| Uses of InitializingBean in org.springframework.jmx.export.naming | 
|---|
| Classes in org.springframework.jmx.export.naming that implement InitializingBean | |
|---|---|
|  class | KeyNamingStrategyObjectNamingStrategyimplementation that buildsObjectNameinstances from the key used in the
 "beans" map passed toMBeanExporter. | 
|  class | MetadataNamingStrategyAn implementation of the ObjectNamingStrategyinterface
 that reads theObjectNamefrom the source-level metadata. | 
| Uses of InitializingBean in org.springframework.jmx.support | 
|---|
| Classes in org.springframework.jmx.support that implement InitializingBean | |
|---|---|
|  class | ConnectorServerFactoryBeanFactoryBeanthat creates a JSR-160JMXConnectorServer,
 optionally registers it with theMBeanServerand then starts it. | 
|  class | MBeanServerConnectionFactoryBeanFactoryBeanthat creates a JMX 1.2MBeanServerConnectionto a remoteMBeanServerexposed via aJMXServerConnector. | 
|  class | MBeanServerFactoryBeanFactoryBean that obtains an MBeanServerreference
 through the standard JMX 1.2MBeanServerFactoryAPI (which is available on JDK 1.5 or as part of a JMX 1.2 provider). | 
|  class | WebLogicJndiMBeanServerFactoryBeanFactoryBean that obtains a specified WebLogic MBeanServerreference through a WebLogicMBeanHomeobtained via a JNDI lookup. | 
|  class | WebLogicMBeanServerFactoryBeanFactoryBean that obtains a specified WebLogic MBeanServerreference through WebLogic's proprietaryHelper/MBeanHomeAPI, which is available on WebLogic 6.1 and higher. | 
|  class | WebSphereMBeanServerFactoryBeanFactoryBean that obtains a WebSphere MBeanServerreference through WebSphere's proprietaryAdminServiceFactoryAPI,
 available on WebSphere 5.1 and higher. | 
| Uses of InitializingBean in org.springframework.jndi | 
|---|
| Classes in org.springframework.jndi that implement InitializingBean | |
|---|---|
|  class | JndiObjectFactoryBeanFactoryBeanthat looks up a
 JNDI object. | 
|  class | JndiObjectLocatorConvenient superclass for JNDI-based service locators, providing configurable lookup of a specific JNDI resource. | 
|  class | JndiObjectTargetSourceAOP TargetSourcethat provides
 configurable JNDI lookups forgetTarget()calls. | 
| Uses of InitializingBean in org.springframework.mail.javamail | 
|---|
| Classes in org.springframework.mail.javamail that implement InitializingBean | |
|---|---|
|  class | ConfigurableMimeFileTypeMapSpring-configurable FileTypeMapimplementation that will read
 MIME type to file extension mappings from a standard JavaMail MIME type
 mapping file, using a standardMimetypesFileTypeMapunderneath. | 
| Uses of InitializingBean in org.springframework.orm.hibernate3 | 
|---|
| Classes in org.springframework.orm.hibernate3 that implement InitializingBean | |
|---|---|
|  class | AbstractSessionFactoryBeanAbstract FactoryBeanthat creates
 a HibernateSessionFactorywithin a Spring application
 context, providing general infrastructure not related to Hibernate's
 specific configuration API. | 
|  class | FilterDefinitionFactoryBeanConvenient FactoryBean for defining Hibernate FilterDefinitions. | 
|  class | HibernateAccessorBase class for HibernateTemplateandHibernateInterceptor,
 defining common properties such as SessionFactory and flushing behavior. | 
|  class | HibernateInterceptorThis 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 | HibernateTemplateHelper class that simplifies Hibernate data access code. | 
|  class | HibernateTransactionManagerPlatformTransactionManagerimplementation for a single HibernateSessionFactory. | 
|  class | LocalSessionFactoryBeanFactoryBeanthat creates a
 HibernateSessionFactory. | 
|  class | TypeDefinitionBeanBean 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 | AnnotationSessionFactoryBeanSubclass of Spring's standard LocalSessionFactoryBean for Hibernate, supporting JDK 1.5+ annotation metadata for mappings. | 
| Uses of InitializingBean in org.springframework.orm.hibernate3.support | 
|---|
| Classes in org.springframework.orm.hibernate3.support that implement InitializingBean | |
|---|---|
|  class | HibernateDaoSupportConvenient super class for Hibernate-based data access objects. | 
|  class | OpenSessionInViewFilterServlet 2.3 Filter that binds a Hibernate Session to the thread for the entire processing of the request. | 
|  class | OpenSessionInViewInterceptorSpring web request interceptor that binds a Hibernate Sessionto 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 | SqlMapClientFactoryBeanFactoryBeanthat creates an
 iBATISSqlMapClient. | 
|  class | SqlMapClientTemplateHelper class that simplifies data access via the iBATIS SqlMapClientAPI, converting checked
 SQLExceptions into unchecked DataAccessExceptions, following theorg.springframework.daoexception hierarchy. | 
| Uses of InitializingBean in org.springframework.orm.ibatis.support | 
|---|
| Classes in org.springframework.orm.ibatis.support that implement InitializingBean | |
|---|---|
|  class | SqlMapClientDaoSupportConvenient 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 | JdoAccessorBase class for JdoTemplate and JdoInterceptor, defining common properties such as PersistenceManagerFactory and flushing behavior. | 
|  class | JdoInterceptorThis 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 | JdoTemplateHelper class that simplifies JDO data access code, and converts JDOExceptions into Spring DataAccessExceptions, following the org.springframework.daoexception hierarchy. | 
|  class | JdoTransactionManagerPlatformTransactionManagerimplementation
 for a single JDOPersistenceManagerFactory. | 
|  class | LocalPersistenceManagerFactoryBeanFactoryBeanthat creates a
 JDOPersistenceManagerFactory. | 
| Uses of InitializingBean in org.springframework.orm.jdo.support | 
|---|
| Classes in org.springframework.orm.jdo.support that implement InitializingBean | |
|---|---|
|  class | JdoDaoSupportConvenient super class for JDO data access objects. | 
|  class | OpenPersistenceManagerInViewFilterServlet 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 | AbstractEntityManagerFactoryBeanAbstract FactoryBeanthat
 creates a local JPAEntityManagerFactoryinstance within a Spring application context. | 
|  class | JpaAccessorBase class for JpaTemplate and JpaInterceptor, defining common properties such as EntityManagerFactory and flushing behavior. | 
|  class | JpaInterceptorThis 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 | JpaTemplateHelper class that allows for writing JPA data access code in the same style as with Spring's well-known JdoTemplate and HibernateTemplate classes. | 
|  class | JpaTransactionManagerPlatformTransactionManagerimplementation
 for a single JPAEntityManagerFactory. | 
|  class | LocalContainerEntityManagerFactoryBeanFactoryBeanthat creates a JPAEntityManagerFactoryaccording to JPA's standard
 container bootstrap contract. | 
|  class | LocalEntityManagerFactoryBeanFactoryBeanthat creates a JPAEntityManagerFactoryaccording 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 | DefaultPersistenceUnitManagerDefault implementation of the PersistenceUnitManagerinterface. | 
| Uses of InitializingBean in org.springframework.orm.jpa.support | 
|---|
| Classes in org.springframework.orm.jpa.support that implement InitializingBean | |
|---|---|
|  class | JpaDaoSupportConvenient super class for JPA data access objects. | 
|  class | OpenEntityManagerInViewFilterServlet 2.3 Filter that binds a JPA EntityManager to the thread for the entire processing of the request. | 
|  class | SharedEntityManagerBeanFactoryBeanthat exposes a shared JPAEntityManagerreference for a given EntityManagerFactory. | 
| Uses of InitializingBean in org.springframework.orm.toplink | 
|---|
| Classes in org.springframework.orm.toplink that implement InitializingBean | |
|---|---|
|  class | TopLinkAccessorBase class for TopLinkTemplate and TopLinkInterceptor, defining common properties such as SessionFactory and JDBC exception translator. | 
|  class | TopLinkInterceptorThis 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 | TopLinkTemplateHelper class that simplifies TopLink data access code, and converts TopLinkExceptions into unchecked DataAccessExceptions, following the org.springframework.daoexception hierarchy. | 
|  class | TopLinkTransactionManagerPlatformTransactionManagerimplementation
 for a single TopLinkSessionFactory. | 
| Uses of InitializingBean in org.springframework.orm.toplink.support | 
|---|
| Classes in org.springframework.orm.toplink.support that implement InitializingBean | |
|---|---|
|  class | TopLinkDaoSupportConvenient 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 | BurlapClientInterceptorMethodInterceptorfor accessing a Burlap service. | 
|  class | BurlapExporterGeneral stream-based protocol exporter for a Burlap endpoint. | 
|  class | BurlapProxyFactoryBeanFactoryBean for Burlap proxies. | 
|  class | BurlapServiceExporterServlet-API-based HTTP request handler that exports the specified service bean as Burlap service endpoint, accessible via a Burlap proxy. | 
|  class | HessianClientInterceptorMethodInterceptorfor accessing a Hessian service. | 
|  class | HessianExporterGeneral stream-based protocol exporter for a Hessian endpoint. | 
|  class | HessianProxyFactoryBeanFactoryBean for Hessian proxies. | 
|  class | HessianServiceExporterServlet-API-based HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy. | 
|  class | SimpleBurlapServiceExporterHTTP request handler that exports the specified service bean as Burlap service endpoint, accessible via a Burlap proxy. | 
|  class | SimpleHessianServiceExporterHTTP 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 | HttpInvokerClientInterceptorMethodInterceptorfor accessing an
 HTTP invoker service. | 
|  class | HttpInvokerProxyFactoryBeanFactoryBean for HTTP invoker proxies. | 
|  class | HttpInvokerServiceExporterServlet-API-based HTTP request handler that exports the specified service bean as HTTP invoker service endpoint, accessible via an HTTP invoker proxy. | 
|  class | SimpleHttpInvokerServiceExporterHTTP 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 | JaxRpcPortClientInterceptorMethodInterceptorfor accessing a specific port
 of a JAX-RPC service. | 
|  class | JaxRpcPortProxyFactoryBeanFactoryBeanfor a specific port of a
 JAX-RPC service. | 
|  class | LocalJaxRpcServiceFactoryBeanFactoryBeanfor locally
 defined JAX-RPC Service references. | 
| Uses of InitializingBean in org.springframework.remoting.jaxws | 
|---|
| Classes in org.springframework.remoting.jaxws that implement InitializingBean | |
|---|---|
|  class | AbstractJaxWsServiceExporterAbstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS WebServiceannotation). | 
|  class | JaxWsPortClientInterceptorMethodInterceptorfor accessing a
 specific port of a JAX-WS service. | 
|  class | JaxWsPortProxyFactoryBeanFactoryBeanfor a specific port of a
 JAX-WS service. | 
|  class | LocalJaxWsServiceFactoryBeanFactoryBeanfor locally
 defined JAX-WS Service references. | 
|  class | SimpleHttpServerJaxWsServiceExporterSimple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS WebServiceannotation) and exporting
 them through the HTTP server included in Sun's JDK 1.6. | 
|  class | SimpleJaxWsServiceExporterSimple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS WebServiceannotation) and exporting
 them with a configured base address (by default "http://localhost:8080/")
 using the JAX-WS provider's built-in publication support. | 
| Uses of InitializingBean in org.springframework.remoting.rmi | 
|---|
| Classes in org.springframework.remoting.rmi that implement InitializingBean | |
|---|---|
|  class | JndiRmiClientInterceptorMethodInterceptorfor accessing RMI services from JNDI. | 
|  class | JndiRmiProxyFactoryBeanFactory bean for RMI proxies from JNDI. | 
|  class | JndiRmiServiceExporterService exporter which binds RMI services to JNDI. | 
|  class | RemoteInvocationSerializingExporterAbstract base class for remote service exporters that explicitly deserialize RemoteInvocationobjects and serializeRemoteInvocationResultobjects,
 for example Spring's HTTP invoker. | 
|  class | RmiClientInterceptorMethodInterceptorfor accessing conventional
 RMI services or RMI invokers. | 
|  class | RmiProxyFactoryBeanFactoryBean for RMI proxies, supporting both conventional RMI services and RMI invokers. | 
|  class | RmiRegistryFactoryBeanFactoryBean that locates a Registryand
 exposes it for bean references. | 
|  class | RmiServiceExporterRMI 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 | RemoteInvocationBasedAccessorAbstract base class for remote service accessors that are based on serialization of RemoteInvocationobjects. | 
|  class | SimpleHttpServerFactoryBeanFactoryBeanthat creates a simple
 HTTP server, based on the HTTP server that is included in Sun's JRE 1.6. | 
|  class | UrlBasedRemoteAccessorAbstract 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 | ScheduledExecutorFactoryBeanFactoryBeanthat sets up
 a JSR-166 backportScheduledExecutorService(by default:ScheduledThreadPoolExecutoras implementation) and exposes it for bean references. | 
|  class | ThreadPoolTaskExecutorJavaBean that allows for configuring a JSR-166 backport ThreadPoolExecutorin bean
 style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
 properties), exposing it as a SpringTaskExecutor. | 
| Uses of InitializingBean in org.springframework.scheduling.commonj | 
|---|
| Classes in org.springframework.scheduling.commonj that implement InitializingBean | |
|---|---|
|  class | TimerManagerFactoryBeanFactoryBeanthat retrieves a
 CommonJTimerManagerand exposes it for bean references. | 
| Uses of InitializingBean in org.springframework.scheduling.quartz | 
|---|
| Classes in org.springframework.scheduling.quartz that implement InitializingBean | |
|---|---|
|  class | CronTriggerBeanConvenience subclass of Quartz's CronTriggerclass, making bean-style usage easier. | 
|  class | JobDetailBeanConvenience subclass of Quartz' JobDetail class that eases bean-style usage. | 
|  class | MethodInvokingJobDetailFactoryBeanFactoryBeanthat exposes aJobDetailobject which delegates job execution to a
 specified (static or non-static) method. | 
|  class | SchedulerAccessorBeanSpring bean-style class for accessing a Quartz Scheduler, i.e. for registering jobs, triggers and listeners on a given Schedulerinstance. | 
|  class | SchedulerFactoryBeanFactoryBeanthat creates and configures a QuartzScheduler,
 manages its lifecycle as part of the Spring application context, and exposes the
 Scheduler as bean reference for dependency injection. | 
|  class | SimpleThreadPoolTaskExecutorSubclass of Quartz's SimpleThreadPool that implements Spring's TaskExecutor interface and listens to Spring lifecycle callbacks. | 
|  class | SimpleTriggerBeanConvenience subclass of Quartz's SimpleTriggerclass, making bean-style usage easier. | 
| Uses of InitializingBean in org.springframework.scheduling.support | 
|---|
| Classes in org.springframework.scheduling.support that implement InitializingBean | |
|---|---|
|  class | MethodInvokingRunnableAdapter that implements the Runnableinterface 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 | MethodInvokingTimerTaskFactoryBeanFactoryBean that exposes a TimerTask object that delegates job execution to a specified (static or non-static) method. | 
|  class | TimerFactoryBeanFactoryBean that sets up a Timerand exposes it for bean references. | 
|  class | TimerTaskExecutorTaskExecutorimplementation that uses a
 singleTimerfor 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 | AttributesTransactionAttributeSourceImplementation of the TransactionAttributeSourceinterface that reads
 metadata via Spring'sAttributesabstraction. | 
|  class | MethodMapTransactionAttributeSourceSimple TransactionAttributeSourceimplementation that
 allows attributes to be stored per method in aMap. | 
|  class | TransactionAspectSupportBase class for transactional aspects, such as the AOP Alliance TransactionInterceptoror an AspectJ aspect. | 
|  class | TransactionInterceptorAOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure ( PlatformTransactionManager). | 
|  class | TransactionProxyFactoryBeanProxy 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 | JtaTransactionManagerPlatformTransactionManagerimplementation
 for JTA, delegating to a backend JTA provider. | 
|  class | OC4JJtaTransactionManagerSpecial JtaTransactionManagervariant for Oracle OC4J (10.1.3 and higher). | 
|  class | WebLogicJtaTransactionManagerSpecial JtaTransactionManagervariant for BEA WebLogic (7.0, 8.1 and higher). | 
|  class | WebSphereUowTransactionManagerWebSphere-specific PlatformTransactionManager implementation that delegates to a UOWManagerinstance, obtained from WebSphere's
 JNDI environment. | 
| Uses of InitializingBean in org.springframework.transaction.support | 
|---|
| Classes in org.springframework.transaction.support that implement InitializingBean | |
|---|---|
|  class | TransactionTemplateTemplate 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 | FreeMarkerConfigurationFactoryBeanFactory 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 | VelocityEngineFactoryBeanFactory bean that configures a VelocityEngine and provides it as bean reference. | 
| Uses of InitializingBean in org.springframework.web.context.support | 
|---|
| Classes in org.springframework.web.context.support that implement InitializingBean | |
|---|---|
|  class | AbstractRefreshableWebApplicationContextAbstractRefreshableApplicationContextsubclass which implements theConfigurableWebApplicationContextinterface for web environments. | 
|  class | XmlWebApplicationContextWebApplicationContextimplementation
 which takes its configuration from XML documents, understood by anXmlBeanDefinitionReader. | 
| Uses of InitializingBean in org.springframework.web.filter | 
|---|
| Classes in org.springframework.web.filter that implement InitializingBean | |
|---|---|
|  class | AbstractRequestLoggingFilterBase class for Filters that perform logging operations before and after a
 request is processed. | 
|  class | CharacterEncodingFilterServlet 2.3/2.4 Filter that allows one to specify a character encoding for requests. | 
|  class | CommonsRequestLoggingFilterSimple request logging filter that writes the request URI (and optionally the query string) to the Commons Log. | 
|  class | DelegatingFilterProxyProxy for a standard Servlet 2.3 Filter, delegating to a Spring-managed bean that implements the Filter interface. | 
|  class | GenericFilterBeanSimple base implementation of Filterwhich treats
 its config parameters (init-paramentries within thefiltertag inweb.xml) as bean properties. | 
|  class | Log4jNestedDiagnosticContextFilterRequest 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 | OncePerRequestFilterFilter base class that guarantees to be just executed once per request, on any servlet container. | 
|  class | RequestContextFilterServlet 2.3 Filter that exposes the request to the current thread, through both LocaleContextHolderandRequestContextHolder. | 
|  class | ServletContextRequestLoggingFilterSimple 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 | MultipartFilterServlet 2.3 Filter that resolves multipart requests via a MultipartResolver. | 
| Uses of InitializingBean in org.springframework.web.portlet.context | 
|---|
| Classes in org.springframework.web.portlet.context that implement InitializingBean | |
|---|---|
|  class | AbstractRefreshablePortletApplicationContextAbstractRefreshableApplicationContextsubclass which implements theConfigurablePortletApplicationContextinterface for portlet environments. | 
|  class | XmlPortletApplicationContextPortlet-based WebApplicationContextimplementation which takes its configuration from XML documents, understood
 by anXmlBeanDefinitionReader. | 
| Uses of InitializingBean in org.springframework.web.portlet.mvc | 
|---|
| Classes in org.springframework.web.portlet.mvc that implement InitializingBean | |
|---|---|
|  class | PortletWrappingControllerControllerimplementation 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 | ServletWrappingControllerSpring 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 | PropertiesMethodNameResolverThe 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 | AbstractTemplateViewAdapter 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 | AbstractUrlBasedViewAbstract base class for URL-based views. | 
|  class | InternalResourceViewWrapper for a JSP or other resource within the same web application. | 
|  class | JstlViewSpecialization of InternalResourceViewfor JSTL pages,
 i.e. | 
|  class | RedirectViewView that redirects to an absolute, context relative, or current request relative URL, by default exposing all model attributes as HTTP query parameters. | 
| Uses of InitializingBean in org.springframework.web.servlet.view.document | 
|---|
| Classes in org.springframework.web.servlet.view.document that implement InitializingBean | |
|---|---|
|  class | AbstractPdfStamperViewAbstract superclass for PDF views that operate on an existing document with an AcroForm. | 
| Uses of InitializingBean in org.springframework.web.servlet.view.freemarker | 
|---|
| Classes in org.springframework.web.servlet.view.freemarker that implement InitializingBean | |
|---|---|
|  class | FreeMarkerConfigurerJavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties. | 
|  class | FreeMarkerViewView 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 | AbstractJasperReportsSingleFormatViewExtends AbstractJasperReportsViewto provide basic rendering logic
 for views that use a fixed format, e.g. always PDF or always HTML. | 
|  class | AbstractJasperReportsViewBase class for all JasperReports views. | 
|  class | ConfigurableJasperReportsViewConfigurable JasperReports View, allowing to specify the JasperReports exporter to be specified through bean properties rather than through the view class name. | 
|  class | JasperReportsCsvViewImplementation of AbstractJasperReportsSingleFormatViewthat renders report results in CSV format. | 
|  class | JasperReportsHtmlViewImplementation of AbstractJasperReportsSingleFormatViewthat renders report results in HTML format. | 
|  class | JasperReportsMultiFormatViewJasper Reports view class that allows for the actual rendering format to be specified at runtime using a parameter contained in the model. | 
|  class | JasperReportsPdfViewImplementation of AbstractJasperReportsSingleFormatViewthat renders report results in PDF format. | 
|  class | JasperReportsXlsViewImplementation of AbstractJasperReportsSingleFormatViewthat 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 | TilesConfigurerHelper class to configure Tiles 1.x for the Spring Framework. | 
|  class | TilesJstlViewSpecialization of TilesViewfor JSTL pages,
 i.e. | 
|  class | TilesViewView 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 | VelocityConfigurerJavaBean to configure Velocity for web usage, via the "configLocation" and/or "velocityProperties" and/or "resourceLoaderPath" bean properties. | 
|  class | VelocityLayoutViewVelocityLayoutView emulates the functionality offered by Velocity's VelocityLayoutServlet to ease page composition from different templates. | 
|  class | VelocityToolboxViewVelocityViewsubclass which adds support for Velocity Tools toolboxes
 and Velocity Tools ViewTool callbacks / Velocity Tools 1.3 init methods. | 
|  class | VelocityViewView 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 | XsltViewXSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation. | 
| 
 | ||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||