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.jca.context	Integration package that allows for deploying a Spring application context as a JCA 1.7 compliant RAR file.
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.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.commonj	Convenience classes for scheduling based on the CommonJ WorkManager/TimerManager facility, as supported by IBM WebSphere 6.0+ and BEA WebLogic 9.0+.
org.springframework.scheduling.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.reactive.socket.server.upgrade	Holds implementations of RequestUpgradeStrategy.
org.springframework.web.socket.client	Client-side abstractions for WebSocket applications.
org.springframework.web.socket.client.standard	Client-side classes for use with standard Java 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 and 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 and 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 javax.inject annotations.

Uses of Lifecycle in org.springframework.context.support

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

Modifier and Type	Class and 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 and 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 and Description
protected int	DefaultLifecycleProcessor.getPhase(Lifecycle bean) Determine the lifecycle phase of the given bean.

Uses of Lifecycle in org.springframework.jca.context

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

Modifier and Type	Class and Description
class	ResourceAdapterApplicationContext ApplicationContext implementation for a JCA ResourceAdapter.

Uses of Lifecycle in org.springframework.jca.endpoint

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

Modifier and Type	Class and Description
class	GenericMessageEndpointManager Generic bean that manages JCA 1.7 message endpoints within a Spring application context, activating and deactivating the endpoint as part of the application context's lifecycle.

Uses of Lifecycle in org.springframework.jms.config

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

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

Uses of Lifecycle in org.springframework.jms.listener

Subinterfaces of Lifecycle in org.springframework.jms.listener

Modifier and Type	Interface and 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 and Description
class	AbstractJmsListeningContainer Common base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt).
class	AbstractMessageListenerContainer Abstract base class for Spring message listener container implementations.
class	AbstractPollingMessageListenerContainer Base class for listener container implementations which are based on polling.
class	DefaultMessageListenerContainer Message listener container variant that uses plain JMS client APIs, specifically a loop of MessageConsumer.receive() calls that also allow for transactional reception of messages (registering them with XA transactions).
class	SimpleMessageListenerContainer Message listener container that uses the plain JMS client API's MessageConsumer.setMessageListener() method to create concurrent MessageConsumers for the specified listeners.

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

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

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

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

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

Modifier and Type	Class and 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 and 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 and 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 and Description
class	UserDestinationMessageHandler MessageHandler with support for "user" destinations.

Uses of Lifecycle in org.springframework.scheduling.commonj

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

Modifier and Type	Class and Description
class	TimerManagerAccessor Deprecated. as of 5.1, in favor of EE 7's DefaultManagedTaskScheduler
class	TimerManagerFactoryBean Deprecated. as of 5.1, in favor of EE 7's DefaultManagedTaskScheduler
class	TimerManagerTaskScheduler Deprecated. as of 5.1, in favor of EE 7's DefaultManagedTaskScheduler

Uses of Lifecycle in org.springframework.scheduling.quartz

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

Modifier and Type	Class and 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 and 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 and Description
class	AbstractRefreshableWebApplicationContext AbstractRefreshableApplicationContext subclass which implements the ConfigurableWebApplicationContext interface for web environments.
class	AnnotationConfigWebApplicationContext WebApplicationContext implementation which accepts component classes as input — in particular @Configuration classes, but also plain @Component classes as well as JSR-330 compliant classes using javax.inject annotations.
class	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 and Description
class	JettyWebSocketClient A WebSocketClient implementation for use with Jetty 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 and 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.reactive.socket.server.upgrade

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

Modifier and Type	Class and Description
class	JettyRequestUpgradeStrategy A RequestUpgradeStrategy for use with Jetty.

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

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

Modifier and Type	Class and 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 and 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 and 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 and 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 and 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 and 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 and 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 and Description
class	DefaultSockJsService A default implementation of SockJsService with all default TransportHandler implementations pre-registered.
class	WebSocketTransportHandler WebSocket-based TransportHandler.