All Classes and Interfaces
Class
Description
Base class for SockJS client implementations of
WebSocketSession.A base class for
HandshakeHandler implementations, independent of the Servlet API.Base class for HTTP transport handlers that receive messages via HTTP POST.
Base class for HTTP transport handlers that push messages to connected clients.
An abstract base class for use with HTTP transport SockJS sessions.
A base class for SockJS message codec that provides an implementation of
AbstractSockJsMessageCodec.encode(String[]).An abstract base class for
SockJsService implementations that provides SockJS
path resolution and handling of static SockJS requests (e.g.An abstract base class for SockJS sessions implementing
SockJsSession.A base class for
RequestUpgradeStrategy implementations that build
on the standard WebSocket API for Java (JSR-356).A base class for events for a message received from a WebSocket client and
parsed into a higher-level sub-protocol (e.g.
Common base class for
TransportHandler implementations.A base class for
RequestUpgradeStrategy implementations on top of
JSR-356 based servers which include Tyrus as their WebSocket engine.Abstract base class for
WebSocketClient implementations.A convenient base class for
WebSocketHandler implementation with empty methods.Base class for
WebSocketHandlerRegistrations that gathers all the configuration
options but allows subclasses to put together the actual HTTP request mappings.A message that can be handled or sent on a WebSocket connection.
An abstract base class for implementations of
WebSocketSession.Abstract base class for XHR transport implementations to extend.
WebSocket
connection manager that connects
to the server via WebSocketContainer and handles the session with an
@ClientEndpoint endpoint.Instantiates a target handler through a Spring
BeanFactory and also provides
an equivalent destroy method.A binary WebSocket message.
A convenient base class for
WebSocketHandler implementations
that process binary messages only.Represents a WebSocket close status code and reason.
Wrap a
WebSocketSession
to guarantee only one thread can send messages at a time.Enum for options of what to do when the buffer fills up.
Base class for a connection manager that automates the process of connecting
to a WebSocket server with the Spring ApplicationContext lifecycle.
A binary
jakarta.websocket.Encoder that delegates
to Spring's conversion service.A binary
jakarta.websocket.Encoder that delegates
to Spring's conversion service.A Text
jakarta.websocket.Encoder that delegates
to Spring's conversion service.A text
jakarta.websocket.Encoder that delegates
to Spring's conversion service.A default
HandshakeHandler implementation,
extending AbstractHandshakeHandler with Servlet-specific initialization support.A default implementation of
SimpUserRegistry that relies on
AbstractSubProtocolEvent application context events to keep
track of connected users and their subscriptions.A default implementation of
SockJsFrameFormat that relies
on String.format(String, Object...)..A default implementation of
SockJsService
with all default TransportHandler implementations pre-registered.A variation of
WebSocketConfigurationSupport that detects implementations of
WebSocketConfigurer in Spring configuration and invokes them in order to
configure WebSocket request handling.A
WebSocketMessageBrokerConfigurationSupport extension that detects
beans of type WebSocketMessageBrokerConfigurer and delegates to all
of them allowing callback style customization of the configuration provided
in WebSocketMessageBrokerConfigurationSupport.Add this annotation to an
@Configuration class to configure
processing WebSocket requests.Add this annotation to an
@Configuration class to enable broker-backed
messaging over WebSocket using a higher-level messaging sub-protocol.WebSocket
connection manager that connects
to the server via WebSocketContainer and handles the session with an
Endpoint.A TransportHandler for sending messages via Server-Sent Events:
https://dev.w3.org/html5/eventsource/.
An exception handling
WebSocketHandlerDecorator.A WebSocket
RequestUpgradeStrategy for Oracle's GlassFish 4.1 and higher.Thrown when handshake processing failed to complete due to an internal, unrecoverable
error.
Contract for processing a WebSocket handshake request.
Interceptor for WebSocket handshake requests.
A helper class that assists with invoking a list of handshake interceptors.
An HTTP
TransportHandler that uses a famous browser
document.domain technique.An interceptor to copy information from the HTTP session to the "handshake
attributes" map to be made available via
WebSocketSession.getAttributes().A component that can execute the SockJS "Info" request that needs to be
performed before the SockJS session starts in order to check server endpoint
capabilities such as whether the endpoint permits use of WebSocket.
A Jackson 2.x codec for encoding and decoding SockJS messages.
A
RequestUpgradeStrategy for Jetty 11.Deprecated, for removal: This API element is subject to removal in a future version.
Adapts
WebSocketHandler to the Jetty 9 WebSocket API.A
WebSocketSession for use with the Jetty 9.4 WebSocket API.An XHR transport based on Jetty's
HttpClient.A
WebSocketHandlerDecorator that adds logging to WebSocket lifecycle events.A
WebSocketSession that exposes the underlying, native WebSocketSession
through a getter.An interceptor to check request
Origin header value against a
collection of allowed origins.A
WebSocketHandler that initializes and destroys a WebSocketHandler
instance for each WebSocket connection and delegates all other methods to it.A WebSocket ping message.
A SockJS session for use with polling HTTP transports.
A WebSocket pong message.
A server-specific strategy for performing the actual upgrade to a WebSocket exchange.
An
XhrTransport implementation that uses a
RestTemplate.Detects beans of type
ServerEndpointConfig and registers
with the standard Jakarta WebSocket runtime.An implementation of
ServerEndpointConfig for use in
Spring-based applications.A
FactoryBean for configuring ServerContainer.A helper class for configuring
WebSocketHandler request handling
including SockJS fallback options.WebSocketHandlerRegistry with Spring MVC handler mappings for the
handshake requests.A connected event represents the server response to a client's connect request.
Event raised when a new WebSocket client using a Simple Messaging Protocol
(e.g.
Event raised when the session of a WebSocket client using a Simple Messaging
Protocol (e.g.
Raised when a WebSocket session has exceeded limits it has been configured
for, e.g.
Event raised when a new WebSocket client using a Simple Messaging Protocol
(e.g.
Event raised when a new WebSocket client using a Simple Messaging Protocol
(e.g.
A SockJS implementation of
WebSocketClient
with fallback alternatives that simulate a WebSocket interaction through plain
HTTP streaming and long polling techniques.Base class for exceptions raised while processing SockJS HTTP requests.
Represents a SockJS frame.
Applies a transport-specific format to the content of a SockJS frame resulting
in a content that can be written out.
SockJS frame types.
An
HttpRequestHandler that allows mapping a SockJsService to requests
in a Servlet container.Encode and decode messages to and from a SockJS message frame,
essentially an array of JSON-encoded messages.
An exception thrown when a message frame was successfully received over an HTTP POST
and parsed but one or more of the messages it contained could not be delivered to the
WebSocketHandler either because the handler failed or because the connection got
closed.
The main entry point for processing HTTP requests from SockJS clients.
Provides transport handling code with access to the
SockJsService configuration
options they need to have access to.A helper class for configuring SockJS fallback options for use with an
EnableWebSocket and
WebSocketConfigurer setup.SockJS extension of Spring's standard
WebSocketSession.A factory for creating a SockJS session.
Indicates a serious failure that occurred in the SockJS implementation as opposed to
in user code (e.g.
An implementation of
WebSocketHandler that adds SockJS messages frames, sends
SockJS heartbeat messages, and delegates lifecycle events and messages to a target
WebSocketHandler.A
ServerEndpointConfig.Configurator for initializing
ServerEndpoint-annotated classes through Spring.A subclass of
WebSocketExtension that can be constructed from a
Extension.A WebSocketClient based on the standard Jakarta WebSocket API.
Adapts a
WebSocketHandler to the standard WebSocket for Java API.A
WebSocketSession for use with the standard WebSocket for Java API.A WebSocket
RequestUpgradeStrategy for the Jakarta WebSocket API 2.1+.A contract for registering STOMP over WebSocket endpoints.
A
SubProtocolErrorHandler for use with STOMP.A
SubProtocolHandler for STOMP that supports versions 1.0, 1.1, and 1.2
of the STOMP specification.Contract for access to session counters.
A contract for configuring a STOMP over WebSocket endpoint.
A SockJS session for use with streaming HTTP transports.
An interface for WebSocket handlers that support sub-protocols as defined in RFC 6455.
A contract for handling sub-protocol errors sent to clients.
A contract for handling WebSocket messages as part of a higher level protocol,
referred to as "sub-protocol" in the WebSocket RFC specification.
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.Contract for access to session counters.
A text WebSocket message.
A convenient base class for
WebSocketHandler implementations
that process text messages only.A WebSocket
RequestUpgradeStrategy for Apache Tomcat.A client-side implementation for a SockJS transport.
Handle a SockJS session URL, i.e.
A basic implementation of
SockJsService
with support for SPI-based transport handling and session management.SockJS transport types.
A WebSocket
RequestUpgradeStrategy for WildFly and its underlying
Undertow web server.An XHR transport based on Undertow's
UndertowClient.A WebSocket
RequestUpgradeStrategy for Oracle's WebLogic.A registry for STOMP over WebSocket endpoints that maps the endpoints with a
HandlerMapping for use in Spring MVC.An abstract base class for configuring STOMP over WebSocket/SockJS endpoints.
A subclass of
SimpAnnotationMethodMessageHandler to provide support
for ControllerAdvice with global @MessageExceptionHandler methods.Contract for initiating a WebSocket request.
An extension of
AbstractClientSockJsSession wrapping and delegating
to an actual WebSocket session.Configuration support for WebSocket request handling.
Defines callback methods to configure the WebSocket request handling
via
@EnableWebSocket.WebSocket
connection manager that connects
to the server via WebSocketClient and handles the session with a
WebSocketHandler.A FactoryBean for creating and configuring a
WebSocketContainer
through Spring XML configuration.Represents a WebSocket extension as defined in the RFC 6455.
A handler for WebSocket messages and lifecycle events.
Wraps another
WebSocketHandler
instance and delegates to it.A factory for applying decorators to a WebSocketHandler.
Extension of
SimpleUrlHandlerMapping with support for more
precise mapping of WebSocket handshake requests to handlers of type
WebSocketHttpRequestHandler.Provides methods for configuring a WebSocket handler.
Provides methods for configuring
WebSocketHandler request mappings.An
HttpHeaders variant that adds support for
the HTTP headers defined by the WebSocket specification RFC 6455.A
HttpRequestHandler for processing WebSocket handshake requests.A message that can be handled or sent on a WebSocket connection.
Extends
AbstractMessageBrokerConfiguration and adds configuration for
receiving and responding to STOMP messages from WebSocket clients.Defines methods for configuring message handling with simple messaging
protocols (e.g.
A central class for aggregating information about internal state and counters
from key infrastructure components of the setup that comes with
@EnableWebSocketMessageBroker for Java config and
<websocket:message-broker> for XML.NamespaceHandler for Spring WebSocket
configuration namespace.A SockJS session for use with the WebSocket transport.
A WebSocket session abstraction.
Wraps another
WebSocketSession instance
and delegates to it.A STOMP over WebSocket client that connects using an implementation of
WebSocketClient
including SockJsClient.Adapter class to convert a
WebSocketExtension to a Jetty
ExtensionConfig.Adapt an instance of
WebSocketExtension to
the Extension interface.A SockJS
Transport that uses a
WebSocketClient.WebSocket-based
TransportHandler.Configure the processing of messages received from and sent to WebSocket clients.
WebSphere support for upgrading an
HttpServletRequest during a
WebSocket handshake.An extension of
AbstractClientSockJsSession for use with HTTP
transports simulating a WebSocket session.A
TransportHandler based on XHR (long) polling.A
TransportHandler that receives messages over HTTP.A
TransportHandler that sends messages over an HTTP streaming request.A SockJS
Transport that uses HTTP requests to simulate a WebSocket
interaction.
StandardWebSocketClient