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.Initiates WebSocket requests to a WebSocket server programmatically
through the Jetty WebSocket API.
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 Java 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 standard Java 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.