Uses of Interface
org.springframework.beans.factory.InitializingBean
Packages that use InitializingBean
Package
Description
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
SPI interfaces and configuration-related convenience classes for bean factories.
Support package for the Java
ServiceLoader
facility.Mechanism to determine bean wiring metadata from a bean instance.
Implementation package for
java.util.concurrent
based caches.AOP-based solution for declarative caching demarcation.
Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
Support classes for the org.springframework.cache package.
Transaction-aware decorators for the org.springframework.cache package.
Support classes for application events, like standard context events.
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
Support classes for DAO implementations,
providing miscellaneous utility methods.
Integration with the JSR-310
java.time
package in JDK 8.Support classes for the formatting package,
providing common implementations as well as adapters.
Abstractions for reactive HTTP client support including
ClientHttpRequest
and
ClientHttpResponse
as well as a
ClientHttpConnector
.This package provides generic HTTP support classes,
to be used by higher-level classes like RestTemplate.
Provides HttpMessageConverter implementations for handling JSON.
This package provides a facility for generic JCA message endpoint management.
Provides generic support classes for JCA usage within Spring,
mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.
Defines the Spring JDBC configuration namespace.
Provides the core JDBC framework, based on JdbcTemplate
and its associated callback interfaces and helper objects.
JdbcTemplate variant with named parameter support.
Classes supporting the
org.springframework.jdbc.core
package.Provides a utility class for easy DataSource access,
a PlatformTransactionManager for a single DataSource,
and various simple DataSource implementations.
Provides extensible support for creating embedded database instances.
Provides extensible support for initializing databases through scripts.
Provides a strategy for looking up JDBC DataSources by name.
The classes in this package represent RDBMS queries, updates,
and stored procedures as threadsafe, reusable objects.
Support classes for the JDBC framework, used by the classes in the
jdbc.core and jdbc.object packages.
Provides a support framework for incrementing database table values
via sequences, with implementations for various databases.
Support package for declarative messaging configuration,
with Java configuration and XML schema support.
Provides a PlatformTransactionManager implementation for a single
JMS ConnectionFactory, and a SingleConnectionFactory adapter.
Core package of the JMS support.
Classes supporting the
org.springframework.jms.core
package.This package contains the base message listener container facility.
This package provides JCA-based endpoint management for JMS message listeners.
This package provides generic JMS support classes,
to be used by higher-level classes like JmsTemplate.
Provides a MessageConverter abstraction to convert
between Java objects and JMS messages.
Support classes for Spring's JMS framework.
Provides support for accessing remote MBean resources.
This package provides declarative creation and registration of
Spring-managed beans as JMX MBeans.
Annotations for MBean exposure.
Provides a strategy for MBeanInfo assembly.
Provides a strategy for ObjectName creation.
Contains support classes for connecting to local and remote
MBeanServer
s
and for exposing an MBeanServer
to remote clients.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.
JavaMail support for Spring's mail infrastructure.
Defines interfaces and implementation classes for messaging templates.
Support classes for working with annotated message-handling methods with
non-blocking, reactive contracts.
Support classes for working with annotated message-handling methods.
Common infrastructure for invoking message handler methods.
Common infrastructure for invoking message handler methods with non-blocking,
and reactive contracts.
Support classes for working with annotated RSocket stream handling methods.
Support classes for handling messages from simple messaging protocols
(like STOMP).
Package providing integration of
Hibernate 5.x
with Spring concepts.
Classes supporting the
org.springframework.orm.hibernate5
package.Package providing integration of JPA (Java Persistence API) with Spring concepts.
Internal support for managing JPA persistence units.
Classes supporting the
org.springframework.orm.jpa
package.Package providing integration of JAXB
with Spring's O/X Mapping support.
Package providing integration of XStream
with Spring's O/X Mapping support.
Provides a utility class for easy ConnectionFactory access,
a ReactiveTransactionManager for a single ConnectionFactory,
and various simple ConnectionFactory implementations.
Provides extensible support for initializing databases through scripts.
Provides a strategy for looking up R2DBC ConnectionFactories by name.
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.Support package for declarative scheduling configuration,
with XML schema being the primary configuration format.
Support classes for the open source scheduler
Quartz,
allowing to set up Quartz Schedulers, JobDetails and
Triggers as beans in a Spring context.
Generic support classes for scheduling.
Support package for declarative transaction configuration,
with XML schema being the primary configuration format.
AOP-based solution for declarative transaction demarcation.
Transaction SPI implementation for JTA.
Support classes for the org.springframework.transaction package.
Support classes for setting up
FreeMarker
within a Spring application context.
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.
This package contains classes used to determine the requested the media types in a request.
Classes supporting the
org.springframework.web.context
package,
such as WebApplicationContext implementations and various utility classes.Provides generic filter base classes allowing for bean-style configuration.
Support classes for the multipart resolution framework.
Classes supporting the
org.springframework.web.reactive.function.server
package.Support classes for serving static resources.
Infrastructure for handler method processing.
Infrastructure for annotation-based handler method processing.
Support for result handling through view resolution.
Support classes for the integration of
FreeMarker
as Spring web view technology.
Support classes for views based on the JSR-223 script engine abstraction
(as included in Java 6+), e.g.
Classes supporting the
org.springframework.web.servlet.function
package.Provides standard HandlerMapping implementations,
including abstract base classes for custom implementations.
Standard controller implementations for the Servlet MVC framework that comes with
Spring.
Servlet-based infrastructure for handler method processing,
building on the
org.springframework.web.method
package.MVC infrastructure for annotation-based handler method processing, building on the
org.springframework.web.method.annotation
package.Support classes for serving static resources.
Provides standard View and ViewResolver implementations,
including abstract base classes for custom implementations.
Support classes for document generation,
providing View implementations for PDF and Excel.
Support classes for the integration of
FreeMarker
as Spring web view technology.
Support classes for the integration of
Groovy Templates as Spring web view technology.
Support classes for views based on the JSR-223 script engine abstraction
(as included in Java 6+), e.g.
Support classes for XSLT,
providing a View implementation for XSLT stylesheets.
WebSocket integration for Spring's messaging module.
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 InitializingBeanModifier and TypeClassDescriptionclass
Convenient superclass forFactoryBean
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 InitializingBeanModifier and TypeClassDescriptionclass
Simple template superclass forFactoryBean
implementations that creates a singleton or a prototype object, depending on a flag.class
FactoryBean
which retrieves a static or non-static field value.class
Simple factory for shared List instances.class
Simple factory for shared Map instances.class
Simple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast toMethodInvokingFactoryBean
).class
FactoryBean
which returns a value which is the result of a static or instance method invocation.class
AFactoryBean
implementation that returns a value which is anObjectFactory
that in turn returns a bean sourced from aBeanFactory
.class
Deprecated.class
Allows for making a properties file from a classpath location available as Properties instance in a bean factory.class
AFactoryBean
implementation that returns a value which is a JSR-330Provider
that in turn returns a bean sourced from aBeanFactory
.class
AFactoryBean
implementation that takes an interface which must have one or more methods with the signaturesMyType xxx()
orMyType xxx(MyIdType id)
(typically,MyService getService()
orMyService getService(String id)
) and creates a dynamic proxy which implements that interface, delegating to an underlyingBeanFactory
.class
Simple factory for shared Set instances.class
Factory for aMap
that reads from a YAML source, preserving the YAML-declared value types and their structure.class
Factory forProperties
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 InitializingBeanModifier and TypeClassDescriptionclass
Abstract base class for FactoryBeans operating on the JDK 1.6ServiceLoader
facility.class
FactoryBean
that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6ServiceLoader
facility.class
FactoryBean
that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6ServiceLoader
facility.class
FactoryBean
that exposes the JDK 1.6ServiceLoader
for the configured service class. -
Uses of InitializingBean in org.springframework.beans.factory.wiring
Classes in org.springframework.beans.factory.wiring that implement InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
FactoryBean
for easy configuration of aConcurrentMapCache
when used within a Spring container. -
Uses of InitializingBean in org.springframework.cache.interceptor
Classes in org.springframework.cache.interceptor that implement InitializingBeanModifier and TypeClassDescriptionclass
A baseCacheResolver
implementation that requires the concrete implementation to provide the collection of cache name(s) based on the invocation context.class
Base class for caching aspects, such as theCacheInterceptor
or an AspectJ aspect.class
AOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure (Cache
).class
Proxy factory bean for simplified declarative caching handling.class
ACacheResolver
that forces the resolution to a configurable collection of name(s) against a givenCacheManager
.class
A simpleCacheResolver
that resolves theCache
instance(s) based on a configurableCacheManager
and the name of the cache(s) as provided bygetCacheNames()
. -
Uses of InitializingBean in org.springframework.cache.jcache
Classes in org.springframework.cache.jcache that implement InitializingBeanModifier and TypeClassDescriptionclass
CacheManager
implementation backed by a JCachejavax.cache.CacheManager
.class
FactoryBean
for a JCachejavax.cache.CacheManager
, obtaining a pre-definedCacheManager
by name through the standard JCachejavax.cache.Caching
class. -
Uses of InitializingBean in org.springframework.cache.jcache.interceptor
Classes in org.springframework.cache.jcache.interceptor that implement InitializingBeanModifier and TypeClassDescriptionclass
Base class for JSR-107 caching aspects, such as theJCacheInterceptor
or an AspectJ aspect.class
AOP Alliance MethodInterceptor for declarative cache management using JSR-107 caching annotations.class
A simpleCacheResolver
that resolves the exception cache based on a configurableCacheManager
and the name of the cache:CacheResultOperation.getExceptionCacheName()
. -
Uses of InitializingBean in org.springframework.cache.support
Classes in org.springframework.cache.support that implement InitializingBeanModifier and TypeClassDescriptionclass
Abstract base class implementing the commonCacheManager
methods.class
CompositeCacheManager
implementation that iterates over a given collection of delegateCacheManager
instances.class
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 InitializingBeanModifier and TypeClassDescriptionclass
Base class for CacheManager implementations that want to support built-in awareness of Spring-managed transactions.class
Proxy for a targetCacheManager
, exposing transaction-awareCache
objects which synchronize theirCache.put(java.lang.Object, java.lang.Object)
operations with Spring-managed transactions (through Spring'sTransactionSynchronizationManager
), 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 InitializingBeanModifier and TypeClassDescriptionclass
Interceptor
that publishes anApplicationEvent
to allApplicationListeners
registered with anApplicationEventPublisher
after each successful method invocation. -
Uses of InitializingBean in org.springframework.context.support
Classes in org.springframework.context.support that implement InitializingBeanModifier and TypeClassDescriptionclass
AbstractRefreshableApplicationContext
subclass that adds common handling of specified config locations.class
Convenient base class forApplicationContext
implementations, drawing configuration from XML documents containing bean definitions understood by anXmlBeanDefinitionReader
.class
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
A factory providing convenient access to a ConversionService configured with converters appropriate for most environments.class
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 InitializingBeanModifier and TypeClassDescriptionclass
Generic base class for DAOs, defining template methods for DAO initialization.class
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 -
Uses of InitializingBean in org.springframework.format.support
Classes in org.springframework.format.support that implement InitializingBeanModifier and TypeClassDescriptionclass
A factory providing convenient access to aFormattingConversionService
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 InitializingBeanModifier and TypeClassDescriptionclass
Factory to manage JDK HttpClient resources such as a sharedExecutor
within the lifecycle of a SpringApplicationContext
.class
Factory to manage Jetty resources, i.e.class
Factory to manage Reactor Netty resources, i.e.class
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 -
Uses of InitializingBean in org.springframework.http.converter.json
Classes in org.springframework.http.converter.json that implement InitializingBeanModifier and TypeClassDescriptionclass
AFactoryBean
for creating a Google Gson 2.xGson
instance.class
AFactoryBean
for creating a Jackson 2.xObjectMapper
(default) orXmlMapper
(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 InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
FactoryBean
that creates a local JCA connection factory in "non-managed" mode (as defined by the Java Connector Architecture specification).class
FactoryBean
that bootstraps the specified JCA 1.7ResourceAdapter
, starting it with a localBootstrapContext
and exposing it for bean references. -
Uses of InitializingBean in org.springframework.jdbc.config
Classes in org.springframework.jdbc.config that implement InitializingBeanModifier and TypeClassDescriptionclass
FactoryBean
implementation that takes a list of location Strings and creates a sorted array ofResource
instances. -
Uses of InitializingBean in org.springframework.jdbc.core
Classes in org.springframework.jdbc.core that implement InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
Convenient superclass for JDBC-based data access objects. -
Uses of InitializingBean in org.springframework.jdbc.datasource
Classes in org.springframework.jdbc.datasource that implement InitializingBeanModifier and TypeClassDescriptionclass
PlatformTransactionManager
implementation for a single JDBCDataSource
.class
JDBCDataSource
implementation that delegates all calls to a given targetDataSource
.class
An adapter for a targetDataSource
, applying the current Spring transaction's isolation level (and potentially specified user credentials) to everygetConnection
call.class
Proxy for a target DataSource, fetching actual JDBC Connections lazily, i.e.class
Proxy for a target JDBCDataSource
, adding awareness of Spring-managed transactions.class
An adapter for a target JDBCDataSource
, applying the specified user credentials to every standardgetConnection()
call, implicitly invokinggetConnection(username, password)
on the target. -
Uses of InitializingBean in org.springframework.jdbc.datasource.embedded
Classes in org.springframework.jdbc.datasource.embedded that implement InitializingBeanModifier and TypeClassDescriptionclass
A subclass ofEmbeddedDatabaseFactory
that implementsFactoryBean
for registration as a Spring bean. -
Uses of InitializingBean in org.springframework.jdbc.datasource.init
Classes in org.springframework.jdbc.datasource.init that implement InitializingBeanModifier and TypeClassDescriptionclass
-
Uses of InitializingBean in org.springframework.jdbc.datasource.lookup
Classes in org.springframework.jdbc.datasource.lookup that implement InitializingBeanModifier and TypeClassDescriptionclass
AbstractDataSource
implementation that routesAbstractRoutingDataSource.getConnection()
calls to one of various target DataSources based on a lookup key.class
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 InitializingBeanModifier and TypeClassDescriptionclass
SqlUpdate subclass that performs batch update operations.class
class
Concrete implementation making it possible to define the RDBMS stored procedures in an application context without writing a custom Java implementation class.class
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
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
An "RDBMS operation" is a multithreaded, reusable object representing a query, update, or stored procedure call.class
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
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
Reusable operation object representing an SQL update.class
Superclass for object abstractions of RDBMS stored procedures.class
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 InitializingBeanModifier and TypeClassDescriptionclass
Registry for customSQLExceptionTranslator
instances for specific databases.class
Bean that checks if a database has already started up.class
Base class forJdbcTemplate
and other JDBC-accessing DAO helpers, defining common properties such as DataSource and exception translator.class
JdbcAccessor
-aligned subclass of the plainDataSourceTransactionManager
, 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 InitializingBeanModifier and TypeClassDescriptionclass
Abstract base class forDataFieldMaxValueIncrementer
implementations that use a column in a custom sequence table.class
Base implementation ofDataFieldMaxValueIncrementer
that delegates to a singleAbstractDataFieldMaxValueIncrementer.getNextKey()
template method that returns along
.class
Abstract base class forDataFieldMaxValueIncrementer
implementations which are based on identity columns in a sequence-like table.class
Abstract base class forDataFieldMaxValueIncrementer
implementations that use a database sequence.class
DataFieldMaxValueIncrementer
that retrieves the next value of a given sequence on DB2 LUW (for Linux, Unix and Windows).class
DataFieldMaxValueIncrementer
that retrieves the next value of a given sequence on DB2 for the mainframe (z/OS, DB2/390, DB2/400).class
DataFieldMaxValueIncrementer
that increments the maximum value of a given Derby table with the equivalent of an auto-increment column.class
DataFieldMaxValueIncrementer
that retrieves the next value of a given H2 sequence.class
DataFieldMaxValueIncrementer
that retrieves the next value of a given SAP HANA sequence.class
DataFieldMaxValueIncrementer
that increments the maximum value of a given HSQL table with the equivalent of an auto-increment column.class
DataFieldMaxValueIncrementer
that retrieves the next value of a given HSQL sequence.class
DataFieldMaxValueIncrementer
that retrieves the next value of a given MariaDB sequence.class
DataFieldMaxValueIncrementer
that increments the maximum value of a given MySQL table with the equivalent of an auto-increment column.class
DataFieldMaxValueIncrementer
that retrieves the next value of a given Oracle sequence.class
DataFieldMaxValueIncrementer
that retrieves the next value of a given PostgreSQL sequence.class
DataFieldMaxValueIncrementer
that increments the maximum value of a given SQL Server table with the equivalent of an auto-increment column.class
DataFieldMaxValueIncrementer
that retrieves the next value of a given SQL Server sequence.class
DataFieldMaxValueIncrementer
that increments the maximum value of a given Sybase table with the equivalent of an auto-increment column.class
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 InitializingBeanModifier and TypeClassDescriptionclass
Helper bean for registeringJmsListenerEndpoint
with aJmsListenerEndpointRegistry
. -
Uses of InitializingBean in org.springframework.jms.connection
Classes in org.springframework.jms.connection that implement InitializingBeanModifier and TypeClassDescriptionclass
SingleConnectionFactory
subclass that addsSession
caching as well asMessageProducer
andMessageConsumer
caching.class
ConnectionFactory
implementation that delegates all calls to a given targetConnectionFactory
, adapting specificcreate(Queue/Topic)Connection
calls to the target ConnectionFactory if necessary (e.g.class
PlatformTransactionManager
implementation for a single JMSConnectionFactory
.class
A JMS ConnectionFactory adapter that returns the same Connection from allSingleConnectionFactory.createConnection()
calls, and ignores calls toConnection.close()
.class
An adapter for a target JMSConnectionFactory
, applying the given user credentials to every standardcreateConnection()
call, that is, implicitly invokingcreateConnection(username, password)
on the target. -
Uses of InitializingBean in org.springframework.jms.core
Classes in org.springframework.jms.core that implement InitializingBeanModifier and TypeClassDescriptionclass
An implementation ofJmsMessageOperations
.class
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 InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
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
Abstract base class for Spring message listener container implementations.class
Base class for listener container implementations which are based on polling.class
Message listener container variant that uses plain JMS client APIs, specifically a loop ofMessageConsumer.receive()
calls that also allow for transactional reception of messages (registering them with XA transactions).class
Message listener container that uses the plain JMS client API'sMessageConsumer.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 InitializingBeanModifier and TypeClassDescriptionclass
Extension of the generic JCA 1.5GenericMessageEndpointManager
, adding JMS-specific support for ActivationSpec configuration. -
Uses of InitializingBean in org.springframework.jms.support
Classes in org.springframework.jms.support that implement InitializingBeanModifier and TypeClassDescriptionclass
Base class forJmsTemplate
and other JMS-accessing gateway helpers, defining common properties such as the JMSConnectionFactory
to operate on. -
Uses of InitializingBean in org.springframework.jms.support.converter
Classes in org.springframework.jms.support.converter that implement InitializingBeanModifier and TypeClassDescriptionclass
class
Convert aMessage
from the messaging abstraction to and from aMessage
using an underlyingMessageConverter
for the payload and aJmsHeaderMapper
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 InitializingBeanModifier and TypeClassDescriptionclass
Base class forJmsTemplate
and other JMS-accessing gateway helpers, adding destination-related properties toJmsAccessor's
common properties. -
Uses of InitializingBean in org.springframework.jmx.access
Classes in org.springframework.jmx.access that implement InitializingBeanModifier and TypeClassDescriptionclass
MethodInterceptor
that routes calls to an MBean running on the suppliedMBeanServerConnection
.class
Creates a proxy to a managed resource running either locally or remotely.class
Registrar object that associates a specificNotificationListener
with one or more MBeans in anMBeanServer
(typically via aMBeanServerConnection
). -
Uses of InitializingBean in org.springframework.jmx.export
Classes in org.springframework.jmx.export that implement InitializingBeanModifier and TypeClassDescriptionclass
JMX exporter that allows for exposing any Spring-managed bean to a JMXMBeanServer
, without the need to define any JMX-specific information in the bean classes.class
Helper class that aggregates aNotificationListener
, aNotificationFilter
, and an arbitrary handback object. -
Uses of InitializingBean in org.springframework.jmx.export.annotation
Classes in org.springframework.jmx.export.annotation that implement InitializingBeanModifier and TypeClassDescriptionclass
Convenient subclass of Spring's standardMBeanExporter
, 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 InitializingBeanModifier and TypeClassDescriptionclass
Subclass ofAbstractReflectiveMBeanInfoAssembler
that allows for the management interface of a bean to be defined using arbitrary interfaces.class
Implementation of theMBeanInfoAssembler
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 InitializingBeanModifier and TypeClassDescriptionclass
ObjectNamingStrategy
implementation that buildsObjectName
instances from the key used in the "beans" map passed toMBeanExporter
.class
An implementation of theObjectNamingStrategy
interface that reads theObjectName
from the source-level metadata. -
Uses of InitializingBean in org.springframework.jmx.support
Classes in org.springframework.jmx.support that implement InitializingBeanModifier and TypeClassDescriptionclass
FactoryBean
that creates a JSR-160JMXConnectorServer
, optionally registers it with theMBeanServer
, and then starts it.class
FactoryBean
that creates a JMX 1.2MBeanServerConnection
to a remoteMBeanServer
exposed via aJMXServerConnector
.class
FactoryBean
that obtains aMBeanServer
reference through the standard JMX 1.2MBeanServerFactory
API. -
Uses of InitializingBean in org.springframework.jndi
Classes in org.springframework.jndi that implement InitializingBeanModifier and TypeClassDescriptionclass
FactoryBean
that looks up a JNDI object.class
Convenient superclass for JNDI-based service locators, providing configurable lookup of a specific JNDI resource.class
AOPTargetSource
that provides configurable JNDI lookups forgetTarget()
calls. -
Uses of InitializingBean in org.springframework.mail.javamail
Classes in org.springframework.mail.javamail that implement InitializingBeanModifier and TypeClassDescriptionclass
Spring-configurableFileTypeMap
implementation that will read MIME type to file extension mappings from a standard JavaMail MIME type mapping file, using a standardMimetypesFileTypeMap
underneath. -
Uses of InitializingBean in org.springframework.messaging.core
Classes in org.springframework.messaging.core that implement InitializingBeanModifier and TypeClassDescriptionclass
DestinationResolver
implementation that proxies a target DestinationResolver, caching itsCachingDestinationResolverProxy.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 InitializingBeanModifier and TypeClassDescriptionclass
Extension ofAbstractMethodMessageHandler
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 InitializingBeanModifier and TypeClassDescriptionclass
The defaultMessageHandlerMethodFactory
implementation creating anInvocableHandlerMethod
with the necessaryHandlerMethodArgumentResolver
instances to detect and process most of the use cases defined byMessageMapping
. -
Uses of InitializingBean in org.springframework.messaging.handler.invocation
Classes in org.springframework.messaging.handler.invocation that implement InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
Extension ofMessageMappingMessageHandler
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 InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
Helper class that simplifies Hibernate data access code.class
PlatformTransactionManager
implementation for a single HibernateSessionFactory
.class
FactoryBean
that creates a HibernateSessionFactory
. -
Uses of InitializingBean in org.springframework.orm.hibernate5.support
Classes in org.springframework.orm.hibernate5.support that implement InitializingBeanModifier and TypeClassDescriptionclass
Convenient superclass for Hibernate-based data access objects.class
Simple AOP AllianceMethodInterceptor
implementation that binds a new HibernateSession
for each method invocation, if none bound before.class
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 InitializingBeanModifier and TypeClassDescriptionclass
AbstractFactoryBean
that creates a local JPAEntityManagerFactory
instance within a Spring application context.class
PlatformTransactionManager
implementation for a single JPAEntityManagerFactory
.class
FactoryBean
that creates a JPAEntityManagerFactory
according to JPA's standard container bootstrap contract.class
FactoryBean
that creates a JPAEntityManagerFactory
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 InitializingBeanModifier and TypeClassDescriptionclass
Default implementation of thePersistenceUnitManager
interface. -
Uses of InitializingBean in org.springframework.orm.jpa.support
Classes in org.springframework.orm.jpa.support that implement InitializingBeanModifier and TypeClassDescriptionclass
Servlet Filter that binds a JPA EntityManager to the thread for the entire processing of the request.class
FactoryBean
that exposes a shared JPAEntityManager
reference for a given EntityManagerFactory. -
Uses of InitializingBean in org.springframework.oxm.jaxb
Classes in org.springframework.oxm.jaxb that implement InitializingBeanModifier and TypeClassDescriptionclass
Implementation of theGenericMarshaller
interface for JAXB 2.2. -
Uses of InitializingBean in org.springframework.oxm.xstream
Classes in org.springframework.oxm.xstream that implement InitializingBeanModifier and TypeClassDescriptionclass
Implementation of theMarshaller
interface for XStream. -
Uses of InitializingBean in org.springframework.r2dbc.connection
Classes in org.springframework.r2dbc.connection that implement InitializingBeanModifier and TypeClassDescriptionclass
ReactiveTransactionManager
implementation for a single R2DBCConnectionFactory
. -
Uses of InitializingBean in org.springframework.r2dbc.connection.init
Classes in org.springframework.r2dbc.connection.init that implement InitializingBeanModifier and TypeClassDescriptionclass
-
Uses of InitializingBean in org.springframework.r2dbc.connection.lookup
Classes in org.springframework.r2dbc.connection.lookup that implement InitializingBeanModifier and TypeClassDescriptionclass
AbstractConnectionFactory
implementation that routesAbstractRoutingConnectionFactory.create()
calls to one of various targetfactories
based on a lookup key. -
Uses of InitializingBean in org.springframework.scheduling.concurrent
Classes in org.springframework.scheduling.concurrent that implement InitializingBeanModifier and TypeClassDescriptionclass
JNDI-based variant ofCustomizableThreadFactory
, performing a default lookup for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Jakarta EE environment, falling back to the localCustomizableThreadFactory
setup if not found.class
JNDI-based variant ofConcurrentTaskExecutor
, performing a default lookup for JSR-236's "java:comp/DefaultManagedExecutorService" in a Jakarta EE/8 environment.class
JNDI-based variant ofConcurrentTaskScheduler
, performing a default lookup for JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Jakarta EE environment.class
Base class for setting up aExecutorService
(typically aThreadPoolExecutor
orScheduledThreadPoolExecutor
).class
A SpringFactoryBean
that builds and exposes a preconfiguredForkJoinPool
.class
FactoryBean
that sets up aScheduledExecutorService
(by default: aScheduledThreadPoolExecutor
) and exposes it for bean references.class
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its nativeExecutorService
type.class
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a SpringTaskExecutor
.class
Implementation of Spring'sTaskScheduler
interface, wrapping a nativeScheduledThreadPoolExecutor
. -
Uses of InitializingBean in org.springframework.scheduling.config
Classes in org.springframework.scheduling.config that implement InitializingBeanModifier and TypeClassDescriptionclass
ScheduledTaskRegistrar
subclass which redirects the actual scheduling of tasks to theContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated()
callback (as of 4.1.2).class
Helper bean for registering tasks with aTaskScheduler
, typically using cron expressions.class
FactoryBean
for creatingThreadPoolTaskExecutor
instances, primarily used behind the XML task namespace. -
Uses of InitializingBean in org.springframework.scheduling.quartz
Classes in org.springframework.scheduling.quartz that implement InitializingBeanModifier and TypeClassDescriptionclass
A SpringFactoryBean
for creating a QuartzCronTrigger
instance, supporting bean-style usage for trigger configuration.class
A SpringFactoryBean
for creating a QuartzJobDetail
instance, supporting bean-style usage for JobDetail configuration.class
FactoryBean
that exposes aJobDetail
object which delegates job execution to a specified (static or non-static) method.class
Spring bean-style class for accessing a Quartz Scheduler, i.e.class
FactoryBean
that creates and configures a QuartzScheduler
, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.class
Subclass of Quartz's SimpleThreadPool that implements Spring'sTaskExecutor
interface and listens to Spring lifecycle callbacks.class
A SpringFactoryBean
for creating a QuartzSimpleTrigger
instance, supporting bean-style usage for trigger configuration. -
Uses of InitializingBean in org.springframework.scheduling.support
Classes in org.springframework.scheduling.support that implement InitializingBeanModifier and TypeClassDescriptionclass
Adapter that implements theRunnable
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 InitializingBeanModifier and TypeClassDescriptionclass
Deprecated.as of 6.0, in favor of a straightJtaTransactionManager
definition -
Uses of InitializingBean in org.springframework.transaction.interceptor
Classes in org.springframework.transaction.interceptor that implement InitializingBeanModifier and TypeClassDescriptionclass
SimpleTransactionAttributeSource
implementation that allows attributes to be stored per method in aMap
.class
SimpleTransactionAttributeSource
implementation that allows attributes to be matched by registered name.class
Base class for transactional aspects, such as theTransactionInterceptor
or an AspectJ aspect.class
AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (PlatformTransactionManager
/ReactiveTransactionManager
).class
Proxy factory bean for simplified declarative transaction handling. -
Uses of InitializingBean in org.springframework.transaction.jta
Classes in org.springframework.transaction.jta that implement InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
SimpleBeanPostProcessor
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
Configurable bean class that exposes a specific JSR-303 Validator through its original interface as well as through the SpringValidator
interface.class
This is the central class forjakarta.validation
(JSR-303) setup in a Spring application context: It bootstraps ajakarta.validation.ValidationFactory
and exposes it through the SpringValidator
interface as well as through the JSR-303Validator
interface and theValidatorFactory
interface itself.class
A convenientBeanPostProcessor
implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.class
LocalValidatorFactoryBean
subclass that simply turnsValidator
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 InitializingBeanModifier and TypeClassDescriptionclass
Factory to create aContentNegotiationManager
and configure it withContentNegotiationStrategy
instances. -
Uses of InitializingBean in org.springframework.web.context.support
Classes in org.springframework.web.context.support that implement InitializingBeanModifier and TypeClassDescriptionclass
AbstractRefreshableApplicationContext
subclass which implements theConfigurableWebApplicationContext
interface for web environments.class
WebApplicationContext
implementation which accepts component classes as input — in particular@Configuration
classes, but also plain@Component
classes as well as JSR-330 compliant classes usingjakarta.inject
annotations.class
WebApplicationContext
implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by aGroovyBeanDefinitionReader
.class
WebApplicationContext
implementation which takes its configuration from XML documents, understood by anXmlBeanDefinitionReader
. -
Uses of InitializingBean in org.springframework.web.filter
Classes in org.springframework.web.filter that implement InitializingBeanModifier and TypeClassDescriptionclass
Base class forFilter
s that perform logging operations before and after a request is processed.class
Servlet Filter that allows one to specify a character encoding for requests.class
Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.class
Filter
to handle CORS pre-flight requests and intercept CORS simple and actual requests with aCorsProcessor
, and to update the response, e.g.class
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.class
Filter
that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.class
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
Simple base implementation ofFilter
which treats its config parameters (init-param
entries within thefilter
tag inweb.xml
) as bean properties.class
Filter
that converts posted method parameters into HTTP methods, retrievable viaHttpServletRequest.getMethod()
.class
Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.class
OverridesHttpServletResponse.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
Servlet Filter that exposes the request to the current thread, through bothLocaleContextHolder
andRequestContextHolder
.class
Filter
that createsobservations
for HTTP exchanges.class
Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.class
Filter
that generates anETag
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 InitializingBeanModifier and TypeClassDescriptionclass
Servlet Filter that resolves multipart requests via aMultipartResolver
. -
Uses of InitializingBean in org.springframework.web.reactive.function.server.support
Classes in org.springframework.web.reactive.function.server.support that implement InitializingBeanModifier and TypeClassDescriptionclass
HandlerMapping
implementation that supportsRouterFunctions
.class
HandlerResultHandler
implementation that supportsServerResponses
. -
Uses of InitializingBean in org.springframework.web.reactive.resource
Classes in org.springframework.web.reactive.resource that implement InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
Abstract base class for classes for whichRequestMappingInfo
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 InitializingBeanModifier and TypeClassDescriptionclass
Supports the invocation of@RequestMapping
handler methods.class
An extension ofRequestMappingInfoHandlerMapping
that createsRequestMappingInfo
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 InitializingBeanModifier and TypeClassDescriptionclass
Abstract base class for URL-based views.class
View that redirects to an absolute or context relative URL.class
AViewResolver
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 InitializingBeanModifier and TypeClassDescriptionclass
Configures FreeMarker for web usage via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.class
AView
implementation that uses the FreeMarker template engine.class
AViewResolver
for resolvingFreeMarkerView
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 InitializingBeanModifier and TypeClassDescriptionclass
AnAbstractUrlBasedView
subclass designed to run any template library based on a JSR-223 script engine.class
Convenience subclass ofUrlBasedViewResolver
that supportsScriptTemplateView
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 InitializingBeanModifier and TypeClassDescriptionclass
HandlerMapping
implementation that supportsRouterFunctions
. -
Uses of InitializingBean in org.springframework.web.servlet.handler
Classes in org.springframework.web.servlet.handler that implement InitializingBeanModifier and TypeClassDescriptionclass
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
Helper class to get information from theHandlerMapping
that would serve a specific request. -
Uses of InitializingBean in org.springframework.web.servlet.mvc
Classes in org.springframework.web.servlet.mvc that implement InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
Abstract base class for classes for whichRequestMappingInfo
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 InitializingBeanModifier and TypeClassDescriptionclass
AnAbstractHandlerMethodExceptionResolver
that resolves exceptions through@ExceptionHandler
methods.class
class
CreatesRequestMappingInfo
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 InitializingBeanModifier and TypeClassDescriptionclass
HttpRequestHandler
that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.class
A filter that wraps theHttpServletResponse
and overrides itsencodeURL
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 InitializingBeanModifier and TypeClassDescriptionclass
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
Abstract base class for URL-based views.class
Implementation ofViewResolver
that resolves a view based on the request file name orAccept
header.class
Wrapper for a JSP or other resource within the same web application.class
Specialization ofInternalResourceView
for JSTL pages, i.e.class
View that redirects to an absolute, context relative, or current request relative URL.class
Deprecated.as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementationsclass
AViewResolver
that delegates to others.class
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 InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
JavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.class
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 InitializingBeanModifier and TypeClassDescriptionclass
An extension of Groovy'sTemplateConfiguration
and an implementation of Spring MVC'sGroovyMarkupConfig
for creating aMarkupTemplateEngine
for use in a web application.class
AnAbstractTemplateView
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 InitializingBeanModifier and TypeClassDescriptionclass
AnAbstractUrlBasedView
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 InitializingBeanModifier and TypeClassDescriptionclass
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 InitializingBeanModifier and TypeClassDescriptionclass
A subclass ofSimpAnnotationMethodMessageHandler
to provide support forControllerAdvice
with global@MessageExceptionHandler
methods. -
Uses of InitializingBean in org.springframework.web.socket.server.standard
Classes in org.springframework.web.socket.server.standard that implement InitializingBeanModifier and TypeClassDescriptionclass
Detects beans of typeServerEndpointConfig
and registers with the standard Jakarta WebSocket runtime.class
AFactoryBean
for configuringServerContainer
.
PropertyPlaceholderConfigurer