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 . |
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. |
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. |
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
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. |
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).
|
Modifier and Type | Method and Description |
---|---|
protected int |
DefaultLifecycleProcessor.getPhase(Lifecycle bean)
Determine the lifecycle phase of the given bean.
|
Modifier and Type | Class and Description |
---|---|
class |
ResourceAdapterApplicationContext
ApplicationContext implementation
for a JCA ResourceAdapter. |
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.
|
Modifier and Type | Class and Description |
---|---|
class |
JmsListenerEndpointRegistry
Creates the necessary
MessageListenerContainer instances for the
registered endpoints. |
Modifier and Type | Interface and Description |
---|---|
interface |
MessageListenerContainer
Internal abstraction used by the framework representing a message
listener container.
|
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. |
Modifier and Type | Class and Description |
---|---|
class |
JmsMessageEndpointManager
Extension of the generic JCA 1.5
GenericMessageEndpointManager ,
adding JMS-specific support for ActivationSpec configuration. |
Modifier and Type | Class and Description |
---|---|
class |
SimpAnnotationMethodMessageHandler
A handler for messages delegating to
@MessageMapping
and @SubscribeMapping annotated methods. |
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. |
Modifier and Type | Class and Description |
---|---|
class |
StompBrokerRelayMessageHandler
A
MessageHandler that handles messages by
forwarding them to a STOMP broker. |
Modifier and Type | Class and Description |
---|---|
class |
UserDestinationMessageHandler
MessageHandler with support for "user" destinations. |
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 |
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. |
Modifier and Type | Interface and Description |
---|---|
interface |
ConfigurableWebApplicationContext
Interface to be implemented by configurable web application contexts.
|
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 . |
Modifier and Type | Class and Description |
---|---|
class |
JettyWebSocketClient
A
WebSocketClient implementation for use with Jetty
WebSocketClient . |
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. |
Modifier and Type | Class and Description |
---|---|
class |
JettyRequestUpgradeStrategy
A
RequestUpgradeStrategy for use with Jetty. |
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 . |
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 . |
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 . |
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. |
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 . |
Modifier and Type | Class and Description |
---|---|
class |
SockJsHttpRequestHandler
An
HttpRequestHandler that allows mapping a SockJsService to requests
in a Servlet container. |
Modifier and Type | Class and Description |
---|---|
class |
TransportHandlingSockJsService
A basic implementation of
SockJsService
with support for SPI-based transport handling and session management. |
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 . |