Uses of Interface
org.springframework.context.Lifecycle
Packages that use Lifecycle
Package
Description
This package builds on the beans package to add support for
message sources and for the Observer design pattern, and the
ability for application objects to obtain resources using a
consistent API.
Annotation support for the Application Context, including JSR-250 "common"
annotations, component-scanning, and Java-based metadata for creating
Spring-managed objects.
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
Abstractions for reactive HTTP client support including
ClientHttpRequest
and
ClientHttpResponse
as well as a
ClientHttpConnector
.This package provides a facility for generic JCA message endpoint management.
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.
This package contains the base message listener container facility.
This package provides JCA-based endpoint management for JMS message listeners.
Support classes for handling messages from simple messaging protocols
(like STOMP).
Provides a "simple" message broker implementation along with an abstract base
class and other supporting types such as a registry for subscriptions.
Generic support for simple messaging protocols (like STOMP).
Support for handling messages to "user" destinations (i.e.
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 classes for the open source scheduler
Quartz,
allowing to set up Quartz Schedulers, JobDetails and
Triggers as beans in a Spring context.
Contains a variant of the application context interface for web applications,
and the ContextLoaderListener that bootstraps a root web application context.
Classes supporting the
org.springframework.web.context
package,
such as WebApplicationContext implementations and various utility classes.Server-side support classes for WebSocket requests.
Client-side abstractions for WebSocket applications.
Client-side classes for use with standard Jakarta WebSocket endpoints.
WebSocket integration for Spring's messaging module.
Server-side support classes including container-specific strategies
for upgrading a request.
SockJS client implementation of
WebSocketClient
.Support classes for SockJS including an
AbstractSockJsService
implementation.Server-side support for SockJS transports including
TransportHandler
implementations
for processing incoming requests, their
session
counterparts for sending messages over the various transports, and
DefaultSockJsService
.TransportHandler
implementation classes as well as a concrete
SockJsService
.-
Uses of Lifecycle in org.springframework.context
Subinterfaces of Lifecycle in org.springframework.contextModifier and TypeInterfaceDescriptioninterface
SPI interface to be implemented by most if not all application contexts.interface
Strategy interface for processing Lifecycle beans within the ApplicationContext.interface
An extension of theLifecycle
interface for those objects that require to be started uponApplicationContext
refresh and/or shutdown in a particular order. -
Uses of Lifecycle in org.springframework.context.annotation
Classes in org.springframework.context.annotation that implement LifecycleModifier and TypeClassDescriptionclass
Standalone application context, accepting component classes as input — in particular@Configuration
-annotated classes, but also plain@Component
types and JSR-330 compliant classes usingjakarta.inject
annotations. -
Uses of Lifecycle in org.springframework.context.support
Classes in org.springframework.context.support that implement LifecycleModifier and TypeClassDescriptionclass
Abstract implementation of theApplicationContext
interface.class
Base class forApplicationContext
implementations which are supposed to support multiple calls toAbstractApplicationContext.refresh()
, creating a new internal bean factory instance every time.class
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
Default implementation of theLifecycleProcessor
strategy.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.class
Generic ApplicationContext implementation that holds a single internalDefaultListableBeanFactory
instance and does not assume a specific bean definition format.class
AnApplicationContext
implementation that extendsGenericApplicationContext
and implementsGroovyObject
such that beans can be retrieved with the dot de-reference syntax instead of usingAbstractApplicationContext.getBean(java.lang.String)
.class
Convenient application context with built-in XML support.class
ApplicationContext
implementation which supports programmatic registration of beans and messages, rather than reading bean definitions from external configuration sources.Methods in org.springframework.context.support that return types with arguments of type LifecycleModifier and TypeMethodDescriptionDefaultLifecycleProcessor.getLifecycleBeans()
Retrieve all applicable Lifecycle beans: all singletons that have already been created, as well as all SmartLifecycle beans (even if they are marked as lazy-init).Methods in org.springframework.context.support with parameters of type Lifecycle -
Uses of Lifecycle in org.springframework.http.client.reactive
Classes in org.springframework.http.client.reactive that implement LifecycleModifier and TypeClassDescriptionclass
Reactor-Netty implementation ofClientHttpConnector
.class
Factory to manage Reactor Netty resources, i.e. -
Uses of Lifecycle in org.springframework.jca.endpoint
Classes in org.springframework.jca.endpoint that implement LifecycleModifier 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 Lifecycle in org.springframework.jms.config
Classes in org.springframework.jms.config that implement LifecycleModifier and TypeClassDescriptionclass
Creates the necessaryMessageListenerContainer
instances for the registered endpoints. -
Uses of Lifecycle in org.springframework.jms.connection
Classes in org.springframework.jms.connection that implement LifecycleModifier and TypeClassDescriptionclass
SingleConnectionFactory
subclass that addsSession
caching as well asMessageProducer
andMessageConsumer
caching.class
A JMS ConnectionFactory adapter that returns the same Connection from allSingleConnectionFactory.createConnection()
calls, and ignores calls toConnection.close()
. -
Uses of Lifecycle in org.springframework.jms.listener
Subinterfaces of Lifecycle in org.springframework.jms.listenerModifier and TypeInterfaceDescriptioninterface
Internal abstraction used by the framework representing a message listener container.Classes in org.springframework.jms.listener that implement LifecycleModifier 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 Lifecycle in org.springframework.jms.listener.endpoint
Classes in org.springframework.jms.listener.endpoint that implement LifecycleModifier and TypeClassDescriptionclass
Extension of the generic JCA 1.5GenericMessageEndpointManager
, adding JMS-specific support for ActivationSpec configuration. -
Uses of Lifecycle in org.springframework.messaging.simp.annotation.support
Classes in org.springframework.messaging.simp.annotation.support that implement LifecycleModifier and TypeClassDescriptionclass
A handler for messages delegating to@MessageMapping
and@SubscribeMapping
annotated methods. -
Uses of Lifecycle in org.springframework.messaging.simp.broker
Classes in org.springframework.messaging.simp.broker that implement LifecycleModifier and TypeClassDescriptionclass
Abstract base class for aMessageHandler
that broker messages to registered subscribers.class
A "simple" message broker that recognizes the message types defined inSimpMessageType
, keeps track of subscriptions with the help of aSubscriptionRegistry
, and sends messages to subscribers. -
Uses of Lifecycle in org.springframework.messaging.simp.stomp
Classes in org.springframework.messaging.simp.stomp that implement LifecycleModifier and TypeClassDescriptionclass
AMessageHandler
that handles messages by forwarding them to a STOMP broker. -
Uses of Lifecycle in org.springframework.messaging.simp.user
Classes in org.springframework.messaging.simp.user that implement LifecycleModifier and TypeClassDescriptionclass
MessageHandler
with support for "user" destinations. -
Uses of Lifecycle in org.springframework.scheduling.concurrent
Classes in org.springframework.scheduling.concurrent that implement LifecycleModifier and TypeClassDescriptionclass
Base class for setting up aExecutorService
(typically aThreadPoolExecutor
orScheduledThreadPoolExecutor
).class
FactoryBean
that sets up aScheduledExecutorService
(by default: aScheduledThreadPoolExecutor
) and exposes it for bean references.class
A simple implementation of Spring'sTaskScheduler
interface, using a single scheduler thread and executing every scheduled task in an individual separate thread.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
A standard implementation of Spring'sTaskScheduler
interface, wrapping a nativeScheduledThreadPoolExecutor
and providing all applicable configuration options for it. -
Uses of Lifecycle in org.springframework.scheduling.quartz
Classes in org.springframework.scheduling.quartz that implement LifecycleModifier and TypeClassDescriptionclass
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. -
Uses of Lifecycle in org.springframework.web.context
Subinterfaces of Lifecycle in org.springframework.web.contextModifier and TypeInterfaceDescriptioninterface
Interface to be implemented by configurable web application contexts. -
Uses of Lifecycle in org.springframework.web.context.support
Classes in org.springframework.web.context.support that implement LifecycleModifier 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
Subclass ofGenericApplicationContext
, suitable for web environments.class
WebApplicationContext
implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by aGroovyBeanDefinitionReader
.class
StaticWebApplicationContext
implementation for testing.class
WebApplicationContext
implementation which takes its configuration from XML documents, understood by anXmlBeanDefinitionReader
. -
Uses of Lifecycle in org.springframework.web.reactive.socket.server.support
Classes in org.springframework.web.reactive.socket.server.support that implement LifecycleModifier and TypeClassDescriptionclass
WebSocketService
implementation that handles a WebSocket HTTP handshake request by delegating to aRequestUpgradeStrategy
which is either auto-detected (no-arg constructor) from the classpath but can also be explicitly configured. -
Uses of Lifecycle in org.springframework.web.socket.client
Classes in org.springframework.web.socket.client that implement LifecycleModifier and TypeClassDescriptionclass
Base class for a connection manager that automates the process of connecting to a WebSocket server with the Spring ApplicationContext lifecycle.class
WebSocketconnection manager
that connects to the server viaWebSocketClient
and handles the session with aWebSocketHandler
. -
Uses of Lifecycle in org.springframework.web.socket.client.standard
Classes in org.springframework.web.socket.client.standard that implement LifecycleModifier and TypeClassDescriptionclass
WebSocketconnection manager
that connects to the server viaWebSocketContainer
and handles the session with an@ClientEndpoint
endpoint.class
WebSocketconnection manager
that connects to the server viaWebSocketContainer
and handles the session with anEndpoint
. -
Uses of Lifecycle in org.springframework.web.socket.messaging
Classes in org.springframework.web.socket.messaging that implement LifecycleModifier and TypeClassDescriptionclass
An implementation ofWebSocketHandler
that delegates incoming WebSocket messages to aSubProtocolHandler
along with aMessageChannel
to which the sub-protocol handler can send messages from WebSocket clients to the application.class
A subclass ofSimpAnnotationMethodMessageHandler
to provide support forControllerAdvice
with global@MessageExceptionHandler
methods.class
A STOMP over WebSocket client that connects using an implementation ofWebSocketClient
includingSockJsClient
. -
Uses of Lifecycle in org.springframework.web.socket.server.support
Classes in org.springframework.web.socket.server.support that implement LifecycleModifier and TypeClassDescriptionclass
A base class forHandshakeHandler
implementations, independent of the Servlet API.class
A defaultHandshakeHandler
implementation, extendingAbstractHandshakeHandler
with Servlet-specific initialization support.class
Extension ofSimpleUrlHandlerMapping
with support for more precise mapping of WebSocket handshake requests to handlers of typeWebSocketHttpRequestHandler
.class
AHttpRequestHandler
for processing WebSocket handshake requests. -
Uses of Lifecycle in org.springframework.web.socket.sockjs.client
Classes in org.springframework.web.socket.sockjs.client that implement LifecycleModifier and TypeClassDescriptionclass
An XHR transport based on Jetty'sHttpClient
.class
A SockJS implementation ofWebSocketClient
with fallback alternatives that simulate a WebSocket interaction through plain HTTP streaming and long polling techniques.class
A SockJSTransport
that uses aWebSocketClient
. -
Uses of Lifecycle in org.springframework.web.socket.sockjs.support
Classes in org.springframework.web.socket.sockjs.support that implement LifecycleModifier and TypeClassDescriptionclass
AnHttpRequestHandler
that allows mapping aSockJsService
to requests in a Servlet container. -
Uses of Lifecycle in org.springframework.web.socket.sockjs.transport
Classes in org.springframework.web.socket.sockjs.transport that implement LifecycleModifier and TypeClassDescriptionclass
A basic implementation ofSockJsService
with support for SPI-based transport handling and session management. -
Uses of Lifecycle in org.springframework.web.socket.sockjs.transport.handler
Classes in org.springframework.web.socket.sockjs.transport.handler that implement LifecycleModifier and TypeClassDescriptionclass
A default implementation ofSockJsService
with all defaultTransportHandler
implementations pre-registered.class
WebSocket-basedTransportHandler
.