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

Packages that use InitializingBean

Package	Description
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 Java ServiceLoader facility.
org.springframework.beans.factory.wiring	Mechanism to determine bean wiring metadata from a bean instance.
org.springframework.cache.concurrent	Implementation package for java.util.concurrent based caches.
org.springframework.cache.ehcache	Support classes for the open source cache EhCache 2.x, allowing to set up an EhCache CacheManager and Caches as beans in a Spring context.
org.springframework.cache.interceptor	AOP-based solution for declarative caching demarcation.
org.springframework.cache.jcache	Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
org.springframework.cache.jcache.interceptor	AOP-based solution for declarative caching demarcation using JSR-107 annotations.
org.springframework.cache.support	Support classes for the org.springframework.cache package.
org.springframework.cache.transaction	Transaction-aware decorators for the org.springframework.cache package.
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.format.datetime.joda	Integration with Joda-Time for formatting Joda date and time types as well as standard JDK Date types.
org.springframework.format.support	Support classes for the formatting package, providing common implementations as well as adapters.
org.springframework.http.client	Contains an abstraction over client-side HTTP.
org.springframework.http.client.reactive	Abstractions for reactive HTTP client support including ClientHttpRequest and ClientHttpResponse as well as a ClientHttpConnector.
org.springframework.http.client.support	This package provides generic HTTP support classes, to be used by higher-level classes like RestTemplate.
org.springframework.http.converter.json	Provides HttpMessageConverter implementations for handling JSON.
org.springframework.jca.cci.connection	Provides a utility class for easy ConnectionFactory access, a PlatformTransactionManager for local CCI transactions, and various simple ConnectionFactory proxies/adapters.
org.springframework.jca.cci.core.support	Classes supporting the org.springframework.jca.cci.core package.
org.springframework.jca.cci.object	The classes in this package represent EIS operations as threadsafe, reusable objects.
org.springframework.jca.endpoint	This package provides a facility for generic JCA message endpoint management.
org.springframework.jca.support	Provides generic support classes for JCA usage within Spring, mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.
org.springframework.jdbc.config	Defines the Spring JDBC configuration namespace.
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.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.embedded	Provides extensible support for creating embedded database instances.
org.springframework.jdbc.datasource.init	Provides extensible support for initializing databases through scripts.
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.config	Support package for declarative messaging configuration, with Java configuration and XML schema support.
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.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.converter	Provides a MessageConverter abstraction to convert between Java objects and JMS messages.
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	Annotations for MBean exposure.
org.springframework.jmx.export.assembler	Provides a strategy for MBeanInfo assembly.
org.springframework.jmx.export.naming	Provides a strategy for ObjectName creation.
org.springframework.jmx.support	Contains support classes for connecting to local and remote MBeanServers and for exposing an MBeanServer to remote clients.
org.springframework.jndi	The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes.
org.springframework.mail.javamail	JavaMail support for Spring's mail infrastructure.
org.springframework.messaging.core	Defines interfaces and implementation classes for messaging templates.
org.springframework.messaging.handler.annotation.reactive	Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
org.springframework.messaging.handler.annotation.support	Support classes for working with annotated message-handling methods.
org.springframework.messaging.handler.invocation.reactive	Common infrastructure for invoking message handler methods with non-blocking, and reactive contracts.
org.springframework.messaging.rsocket.annotation.support	Support classes for working with annotated RSocket stream handling methods.
org.springframework.messaging.simp.annotation.support	Support classes for handling messages from simple messaging protocols (like STOMP).
org.springframework.orm.hibernate5	Package providing integration of Hibernate 5.x with Spring concepts.
org.springframework.orm.hibernate5.support	Classes supporting the org.springframework.orm.hibernate5 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.oxm.jaxb	Package providing integration of JAXB with Spring's O/X Mapping support.
org.springframework.oxm.jibx	Package providing integration of JiBX with Spring's O/X Mapping support.
org.springframework.oxm.xstream	Package providing integration of XStream with Spring's O/X Mapping support.
org.springframework.r2dbc.connection	Provides a utility class for easy ConnectionFactory access, a ReactiveTransactionManager for a single ConnectionFactory, and various simple ConnectionFactory implementations.
org.springframework.r2dbc.connection.init	Provides extensible support for initializing databases through scripts.
org.springframework.r2dbc.connection.lookup	Provides a strategy for looking up R2DBC ConnectionFactories by name.
org.springframework.remoting.caucho	This package provides remoting classes for Caucho's Hessian protocol: a proxy factory for accessing Hessian services, and an exporter for making beans available to Hessian clients.
org.springframework.remoting.httpinvoker	Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
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.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.concurrent	Scheduling convenience classes for the java.util.concurrent and javax.enterprise.concurrent packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
org.springframework.scheduling.config	Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
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.transaction.config	Support package for declarative transaction configuration, with XML schema being the primary configuration format.
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.validation.beanvalidation	Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs.
org.springframework.web.accept	This package contains classes used to determine the requested the media types in a request.
org.springframework.web.context.support	Classes supporting the org.springframework.web.context package, such as WebApplicationContext implementations and various utility classes.
org.springframework.web.filter	Provides generic filter base classes allowing for bean-style configuration.
org.springframework.web.multipart.support	Support classes for the multipart resolution framework.
org.springframework.web.reactive.function.server.support	Classes supporting the org.springframework.web.reactive.function.server package.
org.springframework.web.reactive.resource	Support classes for serving static resources.
org.springframework.web.reactive.result.method	Infrastructure for handler method processing.
org.springframework.web.reactive.result.method.annotation	Infrastructure for annotation-based handler method processing.
org.springframework.web.reactive.result.view	Support for result handling through view resolution.
org.springframework.web.reactive.result.view.freemarker	Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.reactive.result.view.script	Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
org.springframework.web.servlet.handler	Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.mvc	Standard controller implementations for the Servlet MVC framework that comes with Spring.
org.springframework.web.servlet.mvc.method.annotation	MVC infrastructure for annotation-based handler method processing, building on the org.springframework.web.method.annotation package.
org.springframework.web.servlet.resource	Support classes for serving static resources.
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.groovy	Support classes for the integration of Groovy Templates as Spring web view technology.
org.springframework.web.servlet.view.tiles3	Support classes for the integration of Tiles 3 (the standalone version of Tiles) as Spring web view technology.
org.springframework.web.servlet.view.xslt	Support classes for XSLT, providing a View implementation for XSLT stylesheets.
org.springframework.web.socket.messaging	WebSocket integration for Spring's messaging module.
org.springframework.web.socket.server.standard	Server-side classes for use with standard JSR-356 WebSocket endpoints.

Uses of InitializingBean in org.springframework.aop.framework

Classes in org.springframework.aop.framework that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractSingletonProxyFactoryBean Convenient superclass for FactoryBean types that produce singleton-scoped proxy objects.

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

Classes in org.springframework.beans.factory.config that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractFactoryBean<T> Simple template superclass for FactoryBean implementations that creates a singleton or a prototype object, depending on a flag.
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	MethodInvokingBean Simple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast to MethodInvokingFactoryBean).
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 Deprecated. as of 5.2, along with PropertyPlaceholderConfigurer
class	PropertiesFactoryBean Allows for making a properties file from a classpath location available as Properties instance in a bean factory.
class	ProviderCreatingFactoryBean A FactoryBean implementation that returns a value which is a JSR-330 Provider that in turn returns a bean sourced from a BeanFactory.
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.
class	YamlMapFactoryBean Factory for a Map that reads from a YAML source, preserving the YAML-declared value types and their structure.
class	YamlPropertiesFactoryBean Factory for Properties that reads from a YAML source, exposing a flat structure of String property values.

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

Classes in org.springframework.beans.factory.serviceloader that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractServiceLoaderBasedFactoryBean Abstract base class for FactoryBeans operating on the JDK 1.6 ServiceLoader facility.
class	ServiceFactoryBean FactoryBean that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6 ServiceLoader facility.
class	ServiceListFactoryBean FactoryBean that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6 ServiceLoader facility.
class	ServiceLoaderFactoryBean FactoryBean that exposes the JDK 1.6 ServiceLoader for the configured service class.

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

Classes in org.springframework.beans.factory.wiring that implement InitializingBean

Modifier and Type	Class and Description
class	BeanConfigurerSupport Convenient base class for bean configurers that can perform Dependency Injection on objects (however they may be created).

Uses of InitializingBean in org.springframework.cache.concurrent

Classes in org.springframework.cache.concurrent that implement InitializingBean

Modifier and Type	Class and Description
class	ConcurrentMapCacheFactoryBean FactoryBean for easy configuration of a ConcurrentMapCache when used within a Spring container.

Uses of InitializingBean in org.springframework.cache.ehcache

Classes in org.springframework.cache.ehcache that implement InitializingBean

Modifier and Type	Class and Description
class	EhCacheCacheManager CacheManager backed by an EhCache CacheManager.
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.cache.interceptor

Classes in org.springframework.cache.interceptor that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractCacheResolver A base CacheResolver implementation that requires the concrete implementation to provide the collection of cache name(s) based on the invocation context.
class	CacheAspectSupport Base class for caching aspects, such as the CacheInterceptor or an AspectJ aspect.
class	CacheInterceptor AOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure (Cache).
class	CacheProxyFactoryBean Proxy factory bean for simplified declarative caching handling.
class	NamedCacheResolver A CacheResolver that forces the resolution to a configurable collection of name(s) against a given CacheManager.
class	SimpleCacheResolver A simple CacheResolver that resolves the Cache instance(s) based on a configurable CacheManager and the name of the cache(s) as provided by getCacheNames().

Uses of InitializingBean in org.springframework.cache.jcache

Classes in org.springframework.cache.jcache that implement InitializingBean

Modifier and Type	Class and Description
class	JCacheCacheManager CacheManager implementation backed by a JCache javax.cache.CacheManager.
class	JCacheManagerFactoryBean FactoryBean for a JCache javax.cache.CacheManager, obtaining a pre-defined CacheManager by name through the standard JCache javax.cache.Caching class.

Uses of InitializingBean in org.springframework.cache.jcache.interceptor

Classes in org.springframework.cache.jcache.interceptor that implement InitializingBean

Modifier and Type	Class and Description
class	JCacheAspectSupport Base class for JSR-107 caching aspects, such as the JCacheInterceptor or an AspectJ aspect.
class	JCacheInterceptor AOP Alliance MethodInterceptor for declarative cache management using JSR-107 caching annotations.
class	SimpleExceptionCacheResolver A simple CacheResolver that resolves the exception cache based on a configurable CacheManager and the name of the cache: CacheResultOperation.getExceptionCacheName().

Uses of InitializingBean in org.springframework.cache.support

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

Modifier and Type	Class and Description
class	AbstractCacheManager Abstract base class implementing the common CacheManager methods.
class	CompositeCacheManager Composite CacheManager implementation that iterates over a given collection of delegate CacheManager instances.
class	SimpleCacheManager Simple cache manager working against a given collection of caches.

Uses of InitializingBean in org.springframework.cache.transaction

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

Modifier and Type	Class and Description
class	AbstractTransactionSupportingCacheManager Base class for CacheManager implementations that want to support built-in awareness of Spring-managed transactions.
class	TransactionAwareCacheManagerProxy Proxy for a target CacheManager, exposing transaction-aware Cache objects which synchronize their Cache.put(java.lang.Object, java.lang.Object) operations with Spring-managed transactions (through Spring's TransactionSynchronizationManager), performing the actual cache put operation only in the after-commit phase of a successful transaction.

Uses of InitializingBean in org.springframework.context.event

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

Modifier and Type	Class and Description
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

Modifier and Type	Class and Description
class	AbstractRefreshableConfigApplicationContext AbstractRefreshableApplicationContext subclass that adds common handling of specified config locations.
class	AbstractXmlApplicationContext Convenient base class for ApplicationContext implementations, drawing configuration from XML documents containing bean definitions understood by an XmlBeanDefinitionReader.
class	ClassPathXmlApplicationContext Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g.
class	ConversionServiceFactoryBean A factory providing convenient access to a ConversionService configured with converters appropriate for most environments.
class	FileSystemXmlApplicationContext Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g.

Uses of InitializingBean in org.springframework.dao.support

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

Modifier and Type	Class and Description
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

Modifier and Type	Class and Description
class	AbstractRemoteSlsbInvokerInterceptor Base class for interceptors proxying remote Stateless Session Beans.
class	AbstractSlsbInvokerInterceptor Base class for AOP interceptors invoking local or remote Stateless Session Beans.
class	LocalSlsbInvokerInterceptor Invoker for a local Stateless Session Bean.
class	LocalStatelessSessionProxyFactoryBean Convenient FactoryBean for local Stateless Session Bean (SLSB) proxies.
class	SimpleRemoteSlsbInvokerInterceptor Basic invoker for a remote Stateless Session Bean.
class	SimpleRemoteStatelessSessionProxyFactoryBean Convenient FactoryBean for remote SLSB proxies.

Uses of InitializingBean in org.springframework.format.datetime.joda

Classes in org.springframework.format.datetime.joda that implement InitializingBean

Modifier and Type	Class and Description
class	DateTimeFormatterFactoryBean Deprecated. as of 5.3, in favor of standard JSR-310 support

Uses of InitializingBean in org.springframework.format.support

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

Modifier and Type	Class and Description
class	FormattingConversionServiceFactoryBean A factory providing convenient access to a FormattingConversionService configured with converters and formatters for common types such as numbers and datetimes.

Uses of InitializingBean in org.springframework.http.client

Classes in org.springframework.http.client that implement InitializingBean

Modifier and Type	Class and Description
class	HttpComponentsAsyncClientHttpRequestFactory Deprecated. as of Spring 5.0, in favor of HttpComponentsClientHttpConnector
class	Netty4ClientHttpRequestFactory Deprecated. as of Spring 5.0, in favor of ReactorClientHttpConnector

Uses of InitializingBean in org.springframework.http.client.reactive

Classes in org.springframework.http.client.reactive that implement InitializingBean

Modifier and Type	Class and Description
class	JettyResourceFactory Factory to manage Jetty resources, i.e.
class	ReactorResourceFactory Factory to manage Reactor Netty resources, i.e.

Uses of InitializingBean in org.springframework.http.client.support

Classes in org.springframework.http.client.support that implement InitializingBean

Modifier and Type	Class and Description
class	ProxyFactoryBean FactoryBean that creates a java.net.Proxy.

Uses of InitializingBean in org.springframework.http.converter.json

Classes in org.springframework.http.converter.json that implement InitializingBean

Modifier and Type	Class and Description
class	GsonFactoryBean A FactoryBean for creating a Google Gson 2.x Gson instance.
class	Jackson2ObjectMapperFactoryBean A FactoryBean for creating a Jackson 2.x ObjectMapper (default) or XmlMapper (createXmlMapper property set to true) with setters to enable or disable Jackson features from within XML configuration.

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

Classes in org.springframework.jca.cci.connection that implement InitializingBean

Modifier and Type	Class and Description
class	CciLocalTransactionManager Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)
class	ConnectionSpecConnectionFactoryAdapter Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)
class	TransactionAwareConnectionFactoryProxy Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)

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

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

Modifier and Type	Class and Description
class	CciDaoSupport Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)

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

Classes in org.springframework.jca.cci.object that implement InitializingBean

Modifier and Type	Class and Description
class	EisOperation Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)
class	MappingCommAreaOperation Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)
class	MappingRecordOperation Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)
class	SimpleRecordOperation Deprecated. as of 5.3, in favor of specific data access APIs (or native CCI usage if there is no alternative)

Uses of InitializingBean in org.springframework.jca.endpoint

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

Modifier and Type	Class and Description
class	GenericMessageEndpointManager Generic bean that manages JCA 1.7 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

Modifier and Type	Class and Description
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.7 ResourceAdapter, starting it with a local BootstrapContext and exposing it for bean references.

Uses of InitializingBean in org.springframework.jdbc.config

Classes in org.springframework.jdbc.config that implement InitializingBean

Modifier and Type	Class and Description
class	SortedResourcesFactoryBean FactoryBean implementation that takes a list of location Strings and creates a sorted array of Resource instances.

Uses of InitializingBean in org.springframework.jdbc.core

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

Modifier and Type	Class and Description
class	JdbcTemplate This is the central class in the JDBC core package. It simplifies the use of JDBC and helps to avoid common errors.

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

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

Modifier and Type	Class and Description
class	NamedParameterJdbcDaoSupport Extension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well.

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

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

Modifier and Type	Class and Description
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

Modifier and Type	Class and Description
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.
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.embedded

Classes in org.springframework.jdbc.datasource.embedded that implement InitializingBean

Modifier and Type	Class and Description
class	EmbeddedDatabaseFactoryBean A subclass of EmbeddedDatabaseFactory that implements FactoryBean for registration as a Spring bean.

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

Classes in org.springframework.jdbc.datasource.init that implement InitializingBean

Modifier and Type	Class and Description
class	DataSourceInitializer Used to set up a database during initialization and clean up a database during destruction.

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

Classes in org.springframework.jdbc.datasource.lookup that implement InitializingBean

Modifier and Type	Class and Description
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

Modifier and Type	Class and Description
class	BatchSqlUpdate SqlUpdate subclass that performs batch update operations.
class	GenericSqlQuery<T> A concrete variant of SqlQuery which can be configured with a RowMapper.
class	GenericStoredProcedure Concrete implementation making it possible to define the RDBMS stored procedures in an application context without writing a custom Java implementation class.
class	MappingSqlQuery<T> 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<T> Reusable RDBMS query in which concrete subclasses must implement the abstract mapRow(ResultSet, int) method to map each row of the JDBC ResultSet into an object.
class	RdbmsOperation An "RDBMS operation" is a multithreaded, reusable object representing a query, update, or stored procedure call.
class	SqlCall RdbmsOperation using a JdbcTemplate and representing an SQL-based call such as a stored procedure or a stored function.
class	SqlFunction<T> SQL "function" wrapper for a query that returns a single row of results.
class	SqlOperation Operation object representing an SQL-based operation such as a query or update, as opposed to a stored procedure.
class	SqlQuery<T> Reusable operation object representing an SQL query.
class	SqlUpdate Reusable operation object representing an SQL update.
class	StoredProcedure Superclass for object abstractions of RDBMS stored procedures.
class	UpdatableSqlQuery<T> 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

Modifier and Type	Class and Description
class	CustomSQLExceptionTranslatorRegistrar Registry for custom SQLExceptionTranslator instances for specific databases.
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.
class	JdbcTransactionManager JdbcAccessor-aligned subclass of the plain DataSourceTransactionManager, adding common JDBC exception translation for the commit and rollback step.

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

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

Modifier and Type	Class and Description
class	AbstractColumnMaxValueIncrementer Abstract base class for DataFieldMaxValueIncrementer implementations that use a column in a custom sequence table.
class	AbstractDataFieldMaxValueIncrementer Base implementation of DataFieldMaxValueIncrementer that delegates to a single AbstractDataFieldMaxValueIncrementer.getNextKey() template method that returns a long.
class	AbstractIdentityColumnMaxValueIncrementer Abstract base class for DataFieldMaxValueIncrementer implementations which are based on identity columns in a sequence-like table.
class	AbstractSequenceMaxValueIncrementer Abstract base class for DataFieldMaxValueIncrementer implementations that use a database sequence.
class	Db2LuwMaxValueIncrementer DataFieldMaxValueIncrementer that retrieves the next value of a given sequence on DB2 LUW (for Linux, Unix and Windows).
class	Db2MainframeMaxValueIncrementer DataFieldMaxValueIncrementer that retrieves the next value of a given sequence on DB2 for the mainframe (z/OS, DB2/390, DB2/400).
class	DB2MainframeSequenceMaxValueIncrementer Deprecated. in favor of the differently named Db2MainframeMaxValueIncrementer
class	DB2SequenceMaxValueIncrementer Deprecated. in favor of the specifically named Db2LuwMaxValueIncrementer
class	DerbyMaxValueIncrementer DataFieldMaxValueIncrementer that increments the maximum value of a given Derby table with the equivalent of an auto-increment column.
class	H2SequenceMaxValueIncrementer DataFieldMaxValueIncrementer that retrieves the next value of a given H2 sequence.
class	HanaSequenceMaxValueIncrementer DataFieldMaxValueIncrementer that retrieves the next value of a given SAP HANA sequence.
class	HsqlMaxValueIncrementer DataFieldMaxValueIncrementer that increments the maximum value of a given HSQL table with the equivalent of an auto-increment column.
class	HsqlSequenceMaxValueIncrementer DataFieldMaxValueIncrementer that retrieves the next value of a given HSQL sequence.
class	MySQLMaxValueIncrementer DataFieldMaxValueIncrementer that increments the maximum value of a given MySQL table with the equivalent of an auto-increment column.
class	OracleSequenceMaxValueIncrementer DataFieldMaxValueIncrementer that retrieves the next value of a given Oracle sequence.
class	PostgreSQLSequenceMaxValueIncrementer Deprecated. in favor of the differently named PostgresSequenceMaxValueIncrementer
class	PostgresSequenceMaxValueIncrementer DataFieldMaxValueIncrementer that retrieves the next value of a given PostgreSQL sequence.
class	SqlServerMaxValueIncrementer DataFieldMaxValueIncrementer that increments the maximum value of a given SQL Server table with the equivalent of an auto-increment column.
class	SybaseAnywhereMaxValueIncrementer DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table with the equivalent of an auto-increment column.
class	SybaseMaxValueIncrementer DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table with the equivalent of an auto-increment column.

Uses of InitializingBean in org.springframework.jms.config

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

Modifier and Type	Class and Description
class	JmsListenerEndpointRegistrar Helper bean for registering JmsListenerEndpoint with a JmsListenerEndpointRegistry.

Uses of InitializingBean in org.springframework.jms.connection

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

Modifier and Type	Class and Description
class	CachingConnectionFactory SingleConnectionFactory subclass that adds Session caching as well as MessageProducer and MessageConsumer caching.
class	DelegatingConnectionFactory ConnectionFactory implementation that delegates all calls to a given target ConnectionFactory, adapting specific create(Queue/Topic)Connection calls to the target ConnectionFactory if necessary (e.g.
class	JmsTransactionManager PlatformTransactionManager implementation for a single JMS ConnectionFactory.
class	SingleConnectionFactory A JMS ConnectionFactory adapter that returns the same Connection from all SingleConnectionFactory.createConnection() calls, and ignores calls to Connection.close().
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

Modifier and Type	Class and Description
class	JmsMessagingTemplate An implementation of JmsMessageOperations.
class	JmsTemplate Helper class that simplifies synchronous JMS access code.

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

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

Modifier and Type	Class and Description
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

Modifier and Type	Class and Description
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 Spring message listener container implementations.
class	AbstractPollingMessageListenerContainer Base class for listener container implementations which are based on polling.
class	DefaultMessageListenerContainer Message listener container variant that uses plain JMS client APIs, specifically a loop of MessageConsumer.receive() calls that also allow for transactional reception of messages (registering them with XA transactions).
class	SimpleMessageListenerContainer Message listener container that uses the plain JMS client API's MessageConsumer.setMessageListener() method to create concurrent MessageConsumers for the specified listeners.

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

Classes in org.springframework.jms.listener.endpoint that implement InitializingBean

Modifier and Type	Class and Description
class	JmsMessageEndpointManager Extension of the generic JCA 1.5 GenericMessageEndpointManager, adding JMS-specific support for ActivationSpec configuration.

Uses of InitializingBean in org.springframework.jms.remoting

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

Modifier and Type	Class and Description
class	JmsInvokerClientInterceptor Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	JmsInvokerProxyFactoryBean Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	JmsInvokerServiceExporter Deprecated. as of 5.3 (phasing out serialization-based remoting)

Uses of InitializingBean in org.springframework.jms.support

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

Modifier and Type	Class and Description
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.converter

Classes in org.springframework.jms.support.converter that implement InitializingBean

Modifier and Type	Class and Description
class	MarshallingMessageConverter Spring JMS MessageConverter that uses a Marshaller and Unmarshaller.
class	MessagingMessageConverter Convert a Message from the messaging abstraction to and from a Message using an underlying MessageConverter for the payload and a JmsHeaderMapper to map the JMS headers to and from standard message headers.

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

Classes in org.springframework.jms.support.destination that implement InitializingBean

Modifier and Type	Class and Description
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

Modifier and Type	Class and Description
class	MBeanClientInterceptor MethodInterceptor that routes calls to an MBean running on the supplied MBeanServerConnection.
class	MBeanProxyFactoryBean Creates a proxy to a managed resource running either locally or remotely.
class	NotificationListenerRegistrar Registrar object that associates a specific NotificationListener with one or more MBeans in an MBeanServer (typically via a MBeanServerConnection).

Uses of InitializingBean in org.springframework.jmx.export

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

Modifier and Type	Class and Description
class	MBeanExporter JMX exporter that allows for exposing any Spring-managed bean to a JMX MBeanServer, without the need to define any JMX-specific information in the bean classes.
class	NotificationListenerBean Helper class that aggregates a NotificationListener, a NotificationFilter, and an arbitrary handback object.

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

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

Modifier and Type	Class and Description
class	AnnotationMBeanExporter Convenient subclass of Spring's standard MBeanExporter, activating 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

Modifier and Type	Class and Description
class	InterfaceBasedMBeanInfoAssembler Subclass of AbstractReflectiveMBeanInfoAssembler that allows for the management interface of a bean to be defined using arbitrary interfaces.
class	MetadataMBeanInfoAssembler Implementation of the MBeanInfoAssembler interface that reads the management interface information from source level metadata.

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

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

Modifier and Type	Class and Description
class	KeyNamingStrategy ObjectNamingStrategy implementation that builds ObjectName instances from the key used in the "beans" map passed to MBeanExporter.
class	MetadataNamingStrategy An implementation of the ObjectNamingStrategy interface that reads the ObjectName from the source-level metadata.

Uses of InitializingBean in org.springframework.jmx.support

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

Modifier and Type	Class and Description
class	ConnectorServerFactoryBean FactoryBean that creates a JSR-160 JMXConnectorServer, optionally registers it with the MBeanServer, and then starts it.
class	MBeanServerConnectionFactoryBean FactoryBean that creates a JMX 1.2 MBeanServerConnection to a remote MBeanServer exposed via a JMXServerConnector.
class	MBeanServerFactoryBean FactoryBean that obtains a MBeanServer reference through the standard JMX 1.2 MBeanServerFactory API.
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

Modifier and Type	Class and Description
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

Modifier and Type	Class and Description
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.messaging.core

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

Modifier and Type	Class and Description
class	CachingDestinationResolverProxy<D> DestinationResolver implementation that proxies a target DestinationResolver, caching its CachingDestinationResolverProxy.resolveDestination(java.lang.String) results.

Uses of InitializingBean in org.springframework.messaging.handler.annotation.reactive

Classes in org.springframework.messaging.handler.annotation.reactive that implement InitializingBean

Modifier and Type	Class and Description
class	MessageMappingMessageHandler Extension of AbstractMethodMessageHandler for reactive, non-blocking handling of messages via @MessageMapping methods.

Uses of InitializingBean in org.springframework.messaging.handler.annotation.support

Classes in org.springframework.messaging.handler.annotation.support that implement InitializingBean

Modifier and Type	Class and Description
class	DefaultMessageHandlerMethodFactory The default MessageHandlerMethodFactory implementation creating an InvocableHandlerMethod with the necessary HandlerMethodArgumentResolver instances to detect and process most of the use cases defined by MessageMapping.

Uses of InitializingBean in org.springframework.messaging.handler.invocation.reactive

Classes in org.springframework.messaging.handler.invocation.reactive that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractMethodMessageHandler<T> Abstract base class for reactive HandlerMethod-based message handling.

Uses of InitializingBean in org.springframework.messaging.rsocket.annotation.support

Classes in org.springframework.messaging.rsocket.annotation.support that implement InitializingBean

Modifier and Type	Class and Description
class	RSocketMessageHandler Extension of MessageMappingMessageHandler for handling RSocket requests with @ConnectMapping and @MessageMapping methods.

Uses of InitializingBean in org.springframework.messaging.simp.annotation.support

Classes in org.springframework.messaging.simp.annotation.support that implement InitializingBean

Modifier and Type	Class and Description
class	SimpAnnotationMethodMessageHandler A handler for messages delegating to @MessageMapping and @SubscribeMapping annotated methods.

Uses of InitializingBean in org.springframework.orm.hibernate5

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

Modifier and Type	Class and Description
class	HibernateTemplate Helper class that simplifies Hibernate data access code.
class	HibernateTransactionManager PlatformTransactionManager implementation for a single Hibernate SessionFactory.
class	LocalSessionFactoryBean FactoryBean that creates a Hibernate SessionFactory.

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

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

Modifier and Type	Class and Description
class	HibernateDaoSupport Convenient super class for Hibernate-based data access objects.
class	OpenSessionInterceptor Simple AOP Alliance MethodInterceptor implementation that binds a new Hibernate Session for each method invocation, if none bound before.
class	OpenSessionInViewFilter Servlet Filter that binds a Hibernate Session 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

Modifier and Type	Class and Description
class	AbstractEntityManagerFactoryBean Abstract FactoryBean that creates a local JPA EntityManagerFactory instance within a Spring application context.
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

Modifier and Type	Class and Description
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

Modifier and Type	Class and Description
class	OpenEntityManagerInViewFilter Servlet Filter that binds a JPA EntityManager to the thread for the entire processing of the request.
class	SharedEntityManagerBean FactoryBean that exposes a shared JPA EntityManager reference for a given EntityManagerFactory.

Uses of InitializingBean in org.springframework.oxm.jaxb

Classes in org.springframework.oxm.jaxb that implement InitializingBean

Modifier and Type	Class and Description
class	Jaxb2Marshaller Implementation of the GenericMarshaller interface for JAXB 2.2.

Uses of InitializingBean in org.springframework.oxm.jibx

Classes in org.springframework.oxm.jibx that implement InitializingBean

Modifier and Type	Class and Description
class	JibxMarshaller Deprecated. as of Spring Framework 5.1.5, due to the lack of activity on the JiBX project

Uses of InitializingBean in org.springframework.oxm.xstream

Classes in org.springframework.oxm.xstream that implement InitializingBean

Modifier and Type	Class and Description
class	XStreamMarshaller Implementation of the Marshaller interface for XStream.

Uses of InitializingBean in org.springframework.r2dbc.connection

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

Modifier and Type	Class and Description
class	R2dbcTransactionManager ReactiveTransactionManager implementation for a single R2DBC ConnectionFactory.

Uses of InitializingBean in org.springframework.r2dbc.connection.init

Classes in org.springframework.r2dbc.connection.init that implement InitializingBean

Modifier and Type	Class and Description
class	ConnectionFactoryInitializer Used to set up a database during initialization and clean up a database during destruction.

Uses of InitializingBean in org.springframework.r2dbc.connection.lookup

Classes in org.springframework.r2dbc.connection.lookup that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractRoutingConnectionFactory Abstract ConnectionFactory implementation that routes AbstractRoutingConnectionFactory.create() calls to one of various target factories based on a lookup key.

Uses of InitializingBean in org.springframework.remoting.caucho

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

Modifier and Type	Class and Description
class	HessianClientInterceptor Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	HessianExporter Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	HessianProxyFactoryBean Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	HessianServiceExporter Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	SimpleHessianServiceExporter Deprecated. as of Spring Framework 5.1, in favor of HessianServiceExporter

Uses of InitializingBean in org.springframework.remoting.httpinvoker

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

Modifier and Type	Class and Description
class	HttpInvokerClientInterceptor Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	HttpInvokerProxyFactoryBean Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	HttpInvokerServiceExporter Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	SimpleHttpInvokerServiceExporter Deprecated. as of Spring Framework 5.1, in favor of HttpInvokerServiceExporter

Uses of InitializingBean in org.springframework.remoting.jaxws

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

Modifier and Type	Class and Description
class	AbstractJaxWsServiceExporter Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS WebService annotation).
class	JaxWsPortClientInterceptor MethodInterceptor for accessing a specific port of a JAX-WS service.
class	JaxWsPortProxyFactoryBean FactoryBean for a specific port of a JAX-WS service.
class	LocalJaxWsServiceFactoryBean FactoryBean for locally defined JAX-WS Service references.
class	SimpleHttpServerJaxWsServiceExporter Deprecated. as of Spring Framework 5.1, in favor of SimpleJaxWsServiceExporter
class	SimpleJaxWsServiceExporter Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS WebService annotation) and exporting them with a configured base address (by default "http://localhost:8080/") using the JAX-WS provider's built-in publication support.

Uses of InitializingBean in org.springframework.remoting.rmi

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

Modifier and Type	Class and Description
class	JndiRmiClientInterceptor Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	JndiRmiProxyFactoryBean Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	JndiRmiServiceExporter Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	RemoteInvocationSerializingExporter Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	RmiClientInterceptor Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	RmiProxyFactoryBean Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	RmiRegistryFactoryBean Deprecated. as of 5.3 (phasing out serialization-based remoting)
class	RmiServiceExporter Deprecated. as of 5.3 (phasing out serialization-based remoting)

Uses of InitializingBean in org.springframework.remoting.support

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

Modifier and Type	Class and Description
class	RemoteInvocationBasedAccessor Abstract base class for remote service accessors that are based on serialization of RemoteInvocation objects.
class	SimpleHttpServerFactoryBean Deprecated. as of Spring Framework 5.1, in favor of embedded Tomcat/Jetty/Undertow
class	UrlBasedRemoteAccessor Abstract base class for classes that access remote services via URLs.

Uses of InitializingBean in org.springframework.scheduling.commonj

Classes in org.springframework.scheduling.commonj that implement InitializingBean

Modifier and Type	Class and Description
class	TimerManagerAccessor Deprecated. as of 5.1, in favor of EE 7's DefaultManagedTaskScheduler
class	TimerManagerFactoryBean Deprecated. as of 5.1, in favor of EE 7's DefaultManagedTaskScheduler
class	TimerManagerTaskScheduler Deprecated. as of 5.1, in favor of EE 7's DefaultManagedTaskScheduler
class	WorkManagerTaskExecutor Deprecated. as of 5.1, in favor of the EE 7/8 based DefaultManagedTaskExecutor

Uses of InitializingBean in org.springframework.scheduling.concurrent

Classes in org.springframework.scheduling.concurrent that implement InitializingBean

Modifier and Type	Class and Description
class	DefaultManagedAwareThreadFactory JNDI-based variant of CustomizableThreadFactory, performing a default lookup for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Java EE 7 environment, falling back to the local CustomizableThreadFactory setup if not found.
class	DefaultManagedTaskExecutor JNDI-based variant of ConcurrentTaskExecutor, performing a default lookup for JSR-236's "java:comp/DefaultManagedExecutorService" in a Java EE 7/8 environment.
class	DefaultManagedTaskScheduler JNDI-based variant of ConcurrentTaskScheduler, performing a default lookup for JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Java EE 7 environment.
class	ExecutorConfigurationSupport Base class for setting up a ExecutorService (typically a ThreadPoolExecutor or ScheduledThreadPoolExecutor).
class	ForkJoinPoolFactoryBean A Spring FactoryBean that builds and exposes a preconfigured ForkJoinPool.
class	ScheduledExecutorFactoryBean FactoryBean that sets up a ScheduledExecutorService (by default: a ScheduledThreadPoolExecutor) and exposes it for bean references.
class	ThreadPoolExecutorFactoryBean JavaBean that allows for configuring a ThreadPoolExecutor in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its native ExecutorService type.
class	ThreadPoolTaskExecutor JavaBean that allows for configuring a ThreadPoolExecutor in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a Spring TaskExecutor.
class	ThreadPoolTaskScheduler Implementation of Spring's TaskScheduler interface, wrapping a native ScheduledThreadPoolExecutor.

Uses of InitializingBean in org.springframework.scheduling.config

Classes in org.springframework.scheduling.config that implement InitializingBean

Modifier and Type	Class and Description
class	ContextLifecycleScheduledTaskRegistrar ScheduledTaskRegistrar subclass which redirects the actual scheduling of tasks to the ContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated() callback (as of 4.1.2).
class	ScheduledTaskRegistrar Helper bean for registering tasks with a TaskScheduler, typically using cron expressions.
class	TaskExecutorFactoryBean FactoryBean for creating ThreadPoolTaskExecutor instances, primarily used behind the XML task namespace.

Uses of InitializingBean in org.springframework.scheduling.quartz

Classes in org.springframework.scheduling.quartz that implement InitializingBean

Modifier and Type	Class and Description
class	CronTriggerFactoryBean A Spring FactoryBean for creating a Quartz CronTrigger instance, supporting bean-style usage for trigger configuration.
class	JobDetailFactoryBean A Spring FactoryBean for creating a Quartz JobDetail instance, supporting bean-style usage for JobDetail configuration.
class	MethodInvokingJobDetailFactoryBean FactoryBean that exposes a JobDetail object which delegates job execution to a specified (static or non-static) method.
class	SchedulerAccessorBean Spring bean-style class for accessing a Quartz Scheduler, i.e.
class	SchedulerFactoryBean FactoryBean that creates and configures a Quartz Scheduler, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.
class	SimpleThreadPoolTaskExecutor Subclass of Quartz's SimpleThreadPool that implements Spring's TaskExecutor interface and listens to Spring lifecycle callbacks.
class	SimpleTriggerFactoryBean A Spring FactoryBean for creating a Quartz SimpleTrigger instance, supporting bean-style usage for trigger configuration.

Uses of InitializingBean in org.springframework.scheduling.support

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

Modifier and Type	Class and Description
class	MethodInvokingRunnable Adapter that implements the Runnable interface as a configurable method invocation based on Spring's MethodInvoker.

Uses of InitializingBean in org.springframework.transaction.config

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

Modifier and Type	Class and Description
class	JtaTransactionManagerFactoryBean A FactoryBean equivalent to the <tx:jta-transaction-manager/> XML element, autodetecting WebLogic and WebSphere servers and exposing the corresponding JtaTransactionManager subclass.

Uses of InitializingBean in org.springframework.transaction.interceptor

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

Modifier and Type	Class and Description
class	MethodMapTransactionAttributeSource Simple TransactionAttributeSource implementation that allows attributes to be stored per method in a Map.
class	NameMatchTransactionAttributeSource Simple TransactionAttributeSource implementation that allows attributes to be matched by registered name.
class	TransactionAspectSupport Base class for transactional aspects, such as the TransactionInterceptor or an AspectJ aspect.
class	TransactionInterceptor AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (PlatformTransactionManager/ ReactiveTransactionManager).
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

Modifier and Type	Class and Description
class	JtaTransactionManager PlatformTransactionManager implementation for JTA, delegating to a backend JTA provider.
class	WebLogicJtaTransactionManager Special JtaTransactionManager variant for BEA WebLogic (9.0 and higher).
class	WebSphereUowTransactionManager WebSphere-specific PlatformTransactionManager implementation that delegates to a UOWManager instance, obtained from WebSphere's JNDI environment.

Uses of InitializingBean in org.springframework.transaction.support

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

Modifier and Type	Class and Description
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

Modifier and Type	Class and Description
class	FreeMarkerConfigurationFactoryBean Factory bean that creates a FreeMarker Configuration and provides it as bean reference.

Uses of InitializingBean in org.springframework.validation.beanvalidation

Classes in org.springframework.validation.beanvalidation that implement InitializingBean

Modifier and Type	Class and Description
class	BeanValidationPostProcessor Simple BeanPostProcessor that checks JSR-303 constraint annotations in Spring-managed beans, throwing an initialization exception in case of constraint violations right before calling the bean's init method (if any).
class	CustomValidatorBean Configurable bean class that exposes a specific JSR-303 Validator through its original interface as well as through the Spring Validator interface.
class	LocalValidatorFactoryBean This is the central class for javax.validation (JSR-303) setup in a Spring application context: It bootstraps a javax.validation.ValidationFactory and exposes it through the Spring Validator interface as well as through the JSR-303 Validator interface and the ValidatorFactory interface itself.
class	MethodValidationPostProcessor A convenient BeanPostProcessor implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.
class	OptionalValidatorFactoryBean LocalValidatorFactoryBean subclass that simply turns Validator calls into no-ops in case of no Bean Validation provider being available.

Uses of InitializingBean in org.springframework.web.accept

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

Modifier and Type	Class and Description
class	ContentNegotiationManagerFactoryBean Factory to create a ContentNegotiationManager and configure it with ContentNegotiationStrategy instances.

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

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

Modifier and Type	Class and Description
class	AbstractRefreshableWebApplicationContext AbstractRefreshableApplicationContext subclass which implements the ConfigurableWebApplicationContext interface for web environments.
class	AnnotationConfigWebApplicationContext WebApplicationContext implementation which accepts component classes as input — in particular @Configuration classes, but also plain @Component classes as well as JSR-330 compliant classes using javax.inject annotations.
class	GroovyWebApplicationContext WebApplicationContext implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by a GroovyBeanDefinitionReader.
class	XmlWebApplicationContext WebApplicationContext implementation which takes its configuration from XML documents, understood by an XmlBeanDefinitionReader.

Uses of InitializingBean in org.springframework.web.filter

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

Modifier and Type	Class and Description
class	AbstractRequestLoggingFilter Base class for Filters that perform logging operations before and after a request is processed.
class	CharacterEncodingFilter Servlet 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	CorsFilter Filter to handle CORS pre-flight requests and intercept CORS simple and actual requests with a CorsProcessor, and to update the response, e.g.
class	DelegatingFilterProxy Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.
class	FormContentFilter Filter that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.
class	ForwardedHeaderFilter Extract values from "Forwarded" and "X-Forwarded-*" headers, wrap the request and response, and make they reflect the client-originated protocol and address in the following methods: getServerName() getServerPort() getScheme() isSecure() sendRedirect(String).
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	HiddenHttpMethodFilter Filter that converts posted method parameters into HTTP methods, retrievable via HttpServletRequest.getMethod().
class	HttpPutFormContentFilter Deprecated. as of 5.1 in favor of FormContentFilter which is the same but also handles DELETE.
class	OncePerRequestFilter Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.
class	RelativeRedirectFilter Overrides HttpServletResponse.sendRedirect(String) and handles it by setting the HTTP status and "Location" headers, which keeps the Servlet container from re-writing relative redirect URLs into absolute ones.
class	RequestContextFilter Servlet 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.
class	ShallowEtagHeaderFilter Filter that generates an ETag value based on the content on the response.

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

Classes in org.springframework.web.multipart.support that implement InitializingBean

Modifier and Type	Class and Description
class	MultipartFilter Servlet Filter that resolves multipart requests via a MultipartResolver.

Uses of InitializingBean in org.springframework.web.reactive.function.server.support

Classes in org.springframework.web.reactive.function.server.support that implement InitializingBean

Modifier and Type	Class and Description
class	RouterFunctionMapping HandlerMapping implementation that supports RouterFunctions.
class	ServerResponseResultHandler HandlerResultHandler implementation that supports ServerResponses.

Uses of InitializingBean in org.springframework.web.reactive.resource

Classes in org.springframework.web.reactive.resource that implement InitializingBean

Modifier and Type	Class and Description
class	ResourceWebHandler HttpRequestHandler that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.

Uses of InitializingBean in org.springframework.web.reactive.result.method

Classes in org.springframework.web.reactive.result.method that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractHandlerMethodMapping<T> Abstract base class for HandlerMapping implementations that define a mapping between a request and a HandlerMethod.
class	RequestMappingInfoHandlerMapping Abstract base class for classes for which RequestMappingInfo defines the mapping between a request and a handler method.

Uses of InitializingBean in org.springframework.web.reactive.result.method.annotation

Classes in org.springframework.web.reactive.result.method.annotation that implement InitializingBean

Modifier and Type	Class and Description
class	RequestMappingHandlerAdapter Supports the invocation of @RequestMapping handler methods.
class	RequestMappingHandlerMapping An extension of RequestMappingInfoHandlerMapping that creates RequestMappingInfo instances from class-level and method-level @RequestMapping annotations.

Uses of InitializingBean in org.springframework.web.reactive.result.view

Classes in org.springframework.web.reactive.result.view that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractUrlBasedView Abstract base class for URL-based views.
class	RedirectView View that redirects to an absolute or context relative URL.
class	UrlBasedViewResolver A ViewResolver that allows direct resolution of symbolic view names to URLs without explicit mapping definitions.

Uses of InitializingBean in org.springframework.web.reactive.result.view.freemarker

Classes in org.springframework.web.reactive.result.view.freemarker that implement InitializingBean

Modifier and Type	Class and Description
class	FreeMarkerConfigurer Configures FreeMarker for web usage via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
class	FreeMarkerView A View implementation that uses the FreeMarker template engine.
class	FreeMarkerViewResolver A ViewResolver for resolving FreeMarkerView instances, i.e.

Uses of InitializingBean in org.springframework.web.reactive.result.view.script

Classes in org.springframework.web.reactive.result.view.script that implement InitializingBean

Modifier and Type	Class and Description
class	ScriptTemplateView An AbstractUrlBasedView subclass designed to run any template library based on a JSR-223 script engine.
class	ScriptTemplateViewResolver Convenience subclass of UrlBasedViewResolver that supports ScriptTemplateView and custom subclasses of it.

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

Classes in org.springframework.web.servlet.handler that implement InitializingBean

Modifier and Type	Class and Description
class	HandlerMappingIntrospector Helper class to get information from the HandlerMapping that would serve a specific request.

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

Classes in org.springframework.web.servlet.mvc that implement InitializingBean

Modifier and Type	Class and Description
class	ServletWrappingController Spring Controller implementation that wraps a servlet instance which it manages internally.

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

Classes in org.springframework.web.servlet.mvc.method.annotation that implement InitializingBean

Modifier and Type	Class and Description
class	ExceptionHandlerExceptionResolver An AbstractHandlerMethodExceptionResolver that resolves exceptions through @ExceptionHandler methods.

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

Classes in org.springframework.web.servlet.resource that implement InitializingBean

Modifier and Type	Class and Description
class	ResourceHttpRequestHandler HttpRequestHandler that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.
class	ResourceUrlEncodingFilter A filter that wraps the HttpServletResponse and overrides its encodeURL method in order to translate internal resource request URLs into public URL paths for external use.

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

Classes in org.springframework.web.servlet.view that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractTemplateView Adapter base class for template-based view technologies such as FreeMarker, with the ability to use request and session attributes in their model and the option to expose helper objects for Spring's FreeMarker macro library.
class	ContentNegotiatingViewResolver Implementation of ViewResolver that resolves a view based on the request file name or Accept header.
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	ResourceBundleViewResolver Deprecated. as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementations
class	ViewResolverComposite A ViewResolver that delegates to others.
class	XmlViewResolver Deprecated. as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementations

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

Classes in org.springframework.web.servlet.view.document that implement InitializingBean

Modifier and Type	Class and Description
class	AbstractPdfStamperView Abstract superclass for PDF views that operate on an existing document with an AcroForm.

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

Classes in org.springframework.web.servlet.view.groovy that implement InitializingBean

Modifier and Type	Class and Description
class	GroovyMarkupConfigurer An extension of Groovy's TemplateConfiguration and an implementation of Spring MVC's GroovyMarkupConfig for creating a MarkupTemplateEngine for use in a web application.
class	GroovyMarkupView An AbstractTemplateView subclass based on Groovy XML/XHTML markup templates.

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

Classes in org.springframework.web.servlet.view.tiles3 that implement InitializingBean

Modifier and Type	Class and Description
class	TilesConfigurer Helper class to configure Tiles 3.x for the Spring Framework.
class	TilesView View implementation that renders through the Tiles Request API.

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

Classes in org.springframework.web.servlet.view.xslt that implement InitializingBean

Modifier and Type	Class and Description
class	XsltView XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation.

Uses of InitializingBean in org.springframework.web.socket.messaging

Classes in org.springframework.web.socket.messaging that implement InitializingBean

Modifier and Type	Class and Description
class	WebSocketAnnotationMethodMessageHandler A subclass of SimpAnnotationMethodMessageHandler to provide support for ControllerAdvice with global @MessageExceptionHandler methods.

Uses of InitializingBean in org.springframework.web.socket.server.standard

Classes in org.springframework.web.socket.server.standard that implement InitializingBean

Modifier and Type	Class and Description
class	ServerEndpointExporter Detects beans of type ServerEndpointConfig and registers with the standard Java WebSocket runtime.
class	ServletServerContainerFactoryBean A FactoryBean for configuring ServerContainer.