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.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.format.datetime.standard	Integration with the JSR-310 java.time package in JDK 8.
org.springframework.format.support	Support classes for the formatting package, providing common implementations as well as adapters.
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.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.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	Common infrastructure for invoking message handler 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.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.scheduling.concurrent	Scheduling convenience classes for the java.util.concurrent and jakarta.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.function.support	Classes supporting the org.springframework.web.servlet.function package.
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	Servlet-based infrastructure for handler method processing, building on the org.springframework.web.method package.
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.freemarker	Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.servlet.view.groovy	Support classes for the integration of Groovy Templates as Spring web view technology.
org.springframework.web.servlet.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.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	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	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	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	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	Description
class	ConcurrentMapCacheFactoryBean	FactoryBean for easy configuration of a ConcurrentMapCache when used within a Spring container.

Uses of InitializingBean in org.springframework.cache.interceptor

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

Modifier and Type	Class	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	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	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	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	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	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	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	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.format.datetime.standard

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

Modifier and Type	Class	Description
class	DateTimeFormatterFactoryBean	FactoryBean that creates a JSR-310 DateTimeFormatter.

Uses of InitializingBean in org.springframework.format.support

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

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

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

Modifier and Type	Class	Description
class	JdkHttpClientResourceFactory	Factory to manage JDK HttpClient resources such as a shared Executor within the lifecycle of a Spring ApplicationContext.
class	JettyResourceFactory	Factory to manage Jetty resources, i.e.
class	ReactorNetty2ResourceFactory	Factory to manage Reactor Netty 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	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	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.endpoint

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

Modifier and Type	Class	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	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	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	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	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	Description
class	JdbcDaoSupport	Convenient superclass 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	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.

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

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

Modifier and Type	Class	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	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	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	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	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	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	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	MariaDBSequenceMaxValueIncrementer	DataFieldMaxValueIncrementer that retrieves the next value of a given MariaDB 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	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	SqlServerSequenceMaxValueIncrementer	DataFieldMaxValueIncrementer that retrieves the next value of a given SQL Server sequence.
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	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	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	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	Description
class	JmsGatewaySupport	Convenient superclass 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	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	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.support

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

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

Uses of InitializingBean in org.springframework.jndi

Classes in org.springframework.jndi that implement InitializingBean

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

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

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

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	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	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	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	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	Description
class	HibernateDaoSupport	Convenient superclass 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	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	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	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	Description
class	Jaxb2Marshaller	Implementation of the GenericMarshaller interface for JAXB 2.2.

Uses of InitializingBean in org.springframework.oxm.xstream

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

Modifier and Type	Class	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	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	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	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.scheduling.concurrent

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

Modifier and Type	Class	Description
class	DefaultManagedAwareThreadFactory	JNDI-based variant of CustomizableThreadFactory, performing a default lookup for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Jakarta EE 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 Jakarta EE/8 environment.
class	DefaultManagedTaskScheduler	JNDI-based variant of ConcurrentTaskScheduler, performing a default lookup for JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Jakarta EE 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	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	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	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	Description
class	JtaTransactionManagerFactoryBean	Deprecated. as of 6.0, in favor of a straight JtaTransactionManager definition

Uses of InitializingBean in org.springframework.transaction.interceptor

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

Modifier and Type	Class	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	Description
class	JtaTransactionManager	PlatformTransactionManager implementation for JTA, delegating to a backend JTA provider.

Uses of InitializingBean in org.springframework.transaction.support

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

Modifier and Type	Class	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	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	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 jakarta.validation (JSR-303) setup in a Spring application context: It bootstraps a jakarta.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	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	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 jakarta.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	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	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	ServerHttpObservationFilter	Filter that creates observations for HTTP exchanges.
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	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	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	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	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	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	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	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	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.function.support

Classes in org.springframework.web.servlet.function.support that implement InitializingBean

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

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

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

Modifier and Type	Class	Description
class	AbstractHandlerMethodMapping<T>	Abstract base class for HandlerMapping implementations that define a mapping between a request and a HandlerMethod.
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	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

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

Modifier and Type	Class	Description
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.servlet.mvc.method.annotation

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

Modifier and Type	Class	Description
class	ExceptionHandlerExceptionResolver	An AbstractHandlerMethodExceptionResolver that resolves exceptions through @ExceptionHandler methods.
class	RequestMappingHandlerAdapter	Extension of AbstractHandlerMethodAdapter that supports @RequestMapping annotated HandlerMethods.
class	RequestMappingHandlerMapping	Creates RequestMappingInfo instances from type and method-level @RequestMapping annotations in @Controller classes.

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

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

Modifier and Type	Class	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	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	AbstractUrlBasedView	Abstract base class for URL-based views.
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	RedirectView	View that redirects to an absolute, context relative, or current request relative URL.
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	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.freemarker

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

Modifier and Type	Class	Description
class	FreeMarkerConfigurer	JavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
class	FreeMarkerView	View using the FreeMarker template engine.

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

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

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

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

Modifier and Type	Class	Description
class	ScriptTemplateView	An AbstractUrlBasedView subclass designed to run any template library based on a JSR-223 script engine.

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	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	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	Description
class	ServerEndpointExporter	Detects beans of type ServerEndpointConfig and registers with the standard Jakarta WebSocket runtime.
class	ServletServerContainerFactoryBean	A FactoryBean for configuring ServerContainer.