Uses of Interface
org.springframework.context.Lifecycle

Packages that use Lifecycle

Package	Description
org.springframework.context	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.
org.springframework.context.annotation	Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.
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.http.client	Contains an abstraction over client-side HTTP.
org.springframework.http.client.reactive	Abstractions for reactive HTTP client support including ClientHttpRequest and ClientHttpResponse as well as a ClientHttpConnector.
org.springframework.jca.endpoint	This package provides a facility for generic JCA message endpoint management.
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.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.messaging.simp.annotation.support	Support classes for handling messages from simple messaging protocols (like STOMP).
org.springframework.messaging.simp.broker	Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
org.springframework.messaging.simp.stomp	Generic support for simple messaging protocols (like STOMP).
org.springframework.messaging.simp.user	Support for handling messages to "user" destinations (i.e.
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.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.web.context	Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
org.springframework.web.context.support	Classes supporting the org.springframework.web.context package, such as WebApplicationContext implementations and various utility classes.
org.springframework.web.reactive.socket.client	Client support for WebSocket interactions.
org.springframework.web.reactive.socket.server.support	Server-side support classes for WebSocket requests.
org.springframework.web.socket.client	Client-side abstractions for WebSocket applications.
org.springframework.web.socket.client.standard	Client-side classes for use with standard Jakarta WebSocket endpoints.
org.springframework.web.socket.messaging	WebSocket integration for Spring's messaging module.
org.springframework.web.socket.server.support	Server-side support classes including container-specific strategies for upgrading a request.
org.springframework.web.socket.sockjs.client	SockJS client implementation of WebSocketClient.
org.springframework.web.socket.sockjs.support	Support classes for SockJS including an AbstractSockJsService implementation.
org.springframework.web.socket.sockjs.transport	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.
org.springframework.web.socket.sockjs.transport.handler	TransportHandler implementation classes as well as a concrete SockJsService.

Uses of Lifecycle in org.springframework.context

Subinterfaces of Lifecycle in org.springframework.context

Modifier and Type	Interface	Description
interface	ConfigurableApplicationContext	SPI interface to be implemented by most if not all application contexts.
interface	LifecycleProcessor	Strategy interface for processing Lifecycle beans within the ApplicationContext.
interface	SmartLifecycle	An extension of the Lifecycle interface for those objects that require to be started upon ApplicationContext refresh and/or shutdown in a particular order.

Uses of Lifecycle in org.springframework.context.annotation

Classes in org.springframework.context.annotation that implement Lifecycle

Modifier and Type	Class	Description
class	AnnotationConfigApplicationContext	Standalone application context, accepting component classes as input — in particular @Configuration-annotated classes, but also plain @Component types and JSR-330 compliant classes using jakarta.inject annotations.

Uses of Lifecycle in org.springframework.context.support

Classes in org.springframework.context.support that implement Lifecycle

Modifier and Type	Class	Description
class	AbstractApplicationContext	Abstract implementation of the ApplicationContext interface.
class	AbstractRefreshableApplicationContext	Base class for ApplicationContext implementations which are supposed to support multiple calls to AbstractApplicationContext.refresh(), creating a new internal bean factory instance every time.
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	DefaultLifecycleProcessor	Spring's default implementation of the LifecycleProcessor strategy.
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.
class	GenericApplicationContext	Generic ApplicationContext implementation that holds a single internal DefaultListableBeanFactory instance and does not assume a specific bean definition format.
class	GenericGroovyApplicationContext	An ApplicationContext implementation that extends GenericApplicationContext and implements GroovyObject such that beans can be retrieved with the dot de-reference syntax instead of using AbstractApplicationContext.getBean(java.lang.String).
class	GenericXmlApplicationContext	Convenient application context with built-in XML support.
class	StaticApplicationContext	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 Lifecycle

Modifier and Type	Method	Description
protected Map<String,Lifecycle>	DefaultLifecycleProcessor.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

Modifier and Type	Method	Description
protected int	DefaultLifecycleProcessor.getPhase(Lifecycle bean)	Determine the lifecycle phase of the given bean.

Uses of Lifecycle in org.springframework.http.client

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

Modifier and Type	Class	Description
class	ReactorNettyClientRequestFactory	Reactor-Netty implementation of ClientHttpRequestFactory.
class	ReactorResourceFactory	Factory to manage Reactor Netty resources, i.e.

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

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

Modifier and Type	Class	Description
class	ReactorClientHttpConnector	Reactor-Netty implementation of ClientHttpConnector.
class	ReactorResourceFactory	Deprecated. since 6.1 due to a package change; use ReactorResourceFactory instead.

Uses of Lifecycle in org.springframework.jca.endpoint

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

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 Lifecycle in org.springframework.jms.config

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

Modifier and Type	Class	Description
class	JmsListenerEndpointRegistry	Creates the necessary MessageListenerContainer instances for the registered endpoints.

Uses of Lifecycle in org.springframework.jms.connection

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

Modifier and Type	Class	Description
class	CachingConnectionFactory	SingleConnectionFactory subclass that adds Session caching as well as MessageProducer and MessageConsumer caching.
class	SingleConnectionFactory	A JMS ConnectionFactory adapter that returns the same Connection from all SingleConnectionFactory.createConnection() calls, and ignores calls to Connection.close().

Uses of Lifecycle in org.springframework.jms.listener

Subinterfaces of Lifecycle in org.springframework.jms.listener

Modifier and Type	Interface	Description
interface	MessageListenerContainer	Internal abstraction used by the framework representing a message listener container.

Classes in org.springframework.jms.listener that implement Lifecycle

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 Lifecycle in org.springframework.jms.listener.endpoint

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

Modifier and Type	Class	Description
class	JmsMessageEndpointManager	Extension of the generic JCA 1.5 GenericMessageEndpointManager, 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 Lifecycle

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

Modifier and Type	Class	Description
class	AbstractBrokerMessageHandler	Abstract base class for a MessageHandler that broker messages to registered subscribers.
class	SimpleBrokerMessageHandler	A "simple" message broker that recognizes the message types defined in SimpMessageType, keeps track of subscriptions with the help of a SubscriptionRegistry, and sends messages to subscribers.

Uses of Lifecycle in org.springframework.messaging.simp.stomp

Classes in org.springframework.messaging.simp.stomp that implement Lifecycle

Modifier and Type	Class	Description
class	StompBrokerRelayMessageHandler	A MessageHandler 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 Lifecycle

Modifier and Type	Class	Description
class	UserDestinationMessageHandler	MessageHandler with support for "user" destinations.

Uses of Lifecycle in org.springframework.scheduling.concurrent

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

Modifier and Type	Class	Description
class	ExecutorConfigurationSupport	Base class for setting up a ExecutorService (typically a ThreadPoolExecutor or ScheduledThreadPoolExecutor).
class	ScheduledExecutorFactoryBean	FactoryBean that sets up a ScheduledExecutorService (by default: a ScheduledThreadPoolExecutor) and exposes it for bean references.
class	SimpleAsyncTaskScheduler	A simple implementation of Spring's TaskScheduler interface, using a single scheduler thread and executing every scheduled task in an individual separate thread.
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	A standard implementation of Spring's TaskScheduler interface, wrapping a native ScheduledThreadPoolExecutor and providing all applicable configuration options for it.

Uses of Lifecycle in org.springframework.scheduling.quartz

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

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

Uses of Lifecycle in org.springframework.web.context

Subinterfaces of Lifecycle in org.springframework.web.context

Modifier and Type	Interface	Description
interface	ConfigurableWebApplicationContext	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 Lifecycle

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	GenericWebApplicationContext	Subclass of GenericApplicationContext, suitable for web environments.
class	GroovyWebApplicationContext	WebApplicationContext implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by a GroovyBeanDefinitionReader.
class	StaticWebApplicationContext	Static WebApplicationContext implementation for testing.
class	XmlWebApplicationContext	WebApplicationContext implementation which takes its configuration from XML documents, understood by an XmlBeanDefinitionReader.

Uses of Lifecycle in org.springframework.web.reactive.socket.client

Classes in org.springframework.web.reactive.socket.client that implement Lifecycle

Modifier and Type	Class	Description
class	JettyWebSocketClient	A WebSocketClient implementation for use with Jetty 12 WebSocketClient.

Uses of Lifecycle in org.springframework.web.reactive.socket.server.support

Classes in org.springframework.web.reactive.socket.server.support that implement Lifecycle

Modifier and Type	Class	Description
class	HandshakeWebSocketService	WebSocketService implementation that handles a WebSocket HTTP handshake request by delegating to a RequestUpgradeStrategy 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 Lifecycle

Modifier and Type	Class	Description
class	ConnectionManagerSupport	Base class for a connection manager that automates the process of connecting to a WebSocket server with the Spring ApplicationContext lifecycle.
class	WebSocketConnectionManager	WebSocket connection manager that connects to the server via WebSocketClient and handles the session with a WebSocketHandler.

Uses of Lifecycle in org.springframework.web.socket.client.standard

Classes in org.springframework.web.socket.client.standard that implement Lifecycle

Modifier and Type	Class	Description
class	AnnotatedEndpointConnectionManager	WebSocket connection manager that connects to the server via WebSocketContainer and handles the session with an @ClientEndpoint endpoint.
class	EndpointConnectionManager	WebSocket connection manager that connects to the server via WebSocketContainer and handles the session with an Endpoint.

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

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

Modifier and Type	Class	Description
class	SubProtocolWebSocketHandler	An implementation of WebSocketHandler that delegates incoming WebSocket messages to a SubProtocolHandler along with a MessageChannel to which the sub-protocol handler can send messages from WebSocket clients to the application.
class	WebSocketAnnotationMethodMessageHandler	A subclass of SimpAnnotationMethodMessageHandler to provide support for ControllerAdvice with global @MessageExceptionHandler methods.
class	WebSocketStompClient	A STOMP over WebSocket client that connects using an implementation of WebSocketClient including SockJsClient.

Uses of Lifecycle in org.springframework.web.socket.server.support

Classes in org.springframework.web.socket.server.support that implement Lifecycle

Modifier and Type	Class	Description
class	AbstractHandshakeHandler	A base class for HandshakeHandler implementations, independent of the Servlet API.
class	DefaultHandshakeHandler	A default HandshakeHandler implementation, extending AbstractHandshakeHandler with Servlet-specific initialization support.
class	WebSocketHandlerMapping	Extension of SimpleUrlHandlerMapping with support for more precise mapping of WebSocket handshake requests to handlers of type WebSocketHttpRequestHandler.
class	WebSocketHttpRequestHandler	A HttpRequestHandler 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 Lifecycle

Modifier and Type	Class	Description
class	JettyXhrTransport	An XHR transport based on Jetty's HttpClient.
class	SockJsClient	A SockJS implementation of WebSocketClient with fallback alternatives that simulate a WebSocket interaction through plain HTTP streaming and long polling techniques.
class	WebSocketTransport	A SockJS Transport that uses a WebSocketClient.

Uses of Lifecycle in org.springframework.web.socket.sockjs.support

Classes in org.springframework.web.socket.sockjs.support that implement Lifecycle

Modifier and Type	Class	Description
class	SockJsHttpRequestHandler	An HttpRequestHandler that allows mapping a SockJsService 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 Lifecycle

Modifier and Type	Class	Description
class	TransportHandlingSockJsService	A basic implementation of SockJsService 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 Lifecycle

Modifier and Type	Class	Description
class	DefaultSockJsService	A default implementation of SockJsService with all default TransportHandler implementations pre-registered.
class	WebSocketTransportHandler	WebSocket-based TransportHandler.