org.springframework.web.socket.messaging

Class SubProtocolWebSocketHandler

java.lang.Object

org.springframework.web.socket.messaging.SubProtocolWebSocketHandler

All Implemented Interfaces:

Lifecycle, Phased, SmartLifecycle, MessageHandler, SubProtocolCapable, WebSocketHandler

public class SubProtocolWebSocketHandler
extends java.lang.Object
implements WebSocketHandler, SubProtocolCapable, MessageHandler, SmartLifecycle

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.

Also an implementation of MessageHandler that finds the WebSocket session associated with the Message and passes it, along with the message, to the sub-protocol handler to send messages from the application back to the client.

Since:

4.0

Author:

Rossen Stoyanchev, Andy Wilkinson, Artem Bilan

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	SubProtocolWebSocketHandler.Stats
private static class	SubProtocolWebSocketHandler.WebSocketSessionHolder

Field Summary

Fields

Modifier and Type	Field and Description
private MessageChannel	clientInboundChannel
private SubscribableChannel	clientOutboundChannel
private SubProtocolHandler	defaultProtocolHandler
private long	lastSessionCheckTime
private java.lang.Object	lifecycleMonitor
private Log	logger
private java.util.Map<java.lang.String,SubProtocolHandler>	protocolHandlerLookup
private java.util.Set<SubProtocolHandler>	protocolHandlers
private boolean	running
private int	sendBufferSizeLimit
private int	sendTimeLimit
private java.util.concurrent.locks.ReentrantLock	sessionCheckLock
private java.util.Map<java.lang.String,SubProtocolWebSocketHandler.WebSocketSessionHolder>	sessions
private SubProtocolWebSocketHandler.Stats	stats
private static int	TIME_TO_FIRST_MESSAGE Sessions connected to this handler use a sub-protocol.

Constructor Summary

Constructors

Constructor and Description
SubProtocolWebSocketHandler(MessageChannel clientInboundChannel, SubscribableChannel clientOutboundChannel)

Method Summary

Modifier and Type	Method and Description
void	addProtocolHandler(SubProtocolHandler handler) Register a sub-protocol handler.
void	afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) Invoked after the WebSocket connection has been closed by either side, or after a transport error has occurred.
void	afterConnectionEstablished(WebSocketSession session) Invoked after WebSocket negotiation has succeeded and the WebSocket connection is opened and ready for use.
private void	checkSessions() When a session is connected through a higher-level protocol it has a chance to use heartbeat management to shut down sessions that are too slow to send or receive messages.
private void	clearSession(WebSocketSession session, CloseStatus closeStatus)
protected SubProtocolHandler	findProtocolHandler(WebSocketSession session)
SubProtocolHandler	getDefaultProtocolHandler()
int	getPhase() Return the phase value of this object.
java.util.Map<java.lang.String,SubProtocolHandler>	getProtocolHandlerMap() Return the sub-protocols keyed by protocol name.
java.util.List<SubProtocolHandler>	getProtocolHandlers()
int	getSendBufferSizeLimit()
int	getSendTimeLimit()
java.lang.String	getStatsInfo() Return a String describing internal state and counters.
java.util.List<java.lang.String>	getSubProtocols() Return all supported protocols.
void	handleMessage(Message<?> message) Handle an outbound Spring Message to a WebSocket client.
void	handleMessage(WebSocketSession session, WebSocketMessage<?> message) Handle an inbound message from a WebSocket client.
void	handleTransportError(WebSocketSession session, java.lang.Throwable exception) Handle an error from the underlying WebSocket message transport.
boolean	isAutoStartup() Returns true if this Lifecycle component should get started automatically by the container at the time that the containing ApplicationContext gets refreshed.
boolean	isRunning() Check whether this component is currently running.
private java.lang.String	resolveSessionId(Message<?> message)
void	setDefaultProtocolHandler(SubProtocolHandler defaultProtocolHandler) Set the SubProtocolHandler to use when the client did not request a sub-protocol.
void	setProtocolHandlers(java.util.List<SubProtocolHandler> protocolHandlers) Configure one or more handlers to use depending on the sub-protocol requested by the client in the WebSocket handshake request.
void	setSendBufferSizeLimit(int sendBufferSizeLimit)
void	setSendTimeLimit(int sendTimeLimit)
void	start() Start this component.
void	stop() Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method.
void	stop(java.lang.Runnable callback) Indicates that a Lifecycle component must stop if it is currently running.
boolean	supportsPartialMessages() Whether the WebSocketHandler handles partial messages.
java.lang.String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

TIME_TO_FIRST_MESSAGE

private static final int TIME_TO_FIRST_MESSAGE

Sessions connected to this handler use a sub-protocol. Hence we expect to receive some client messages. If we don't receive any within a minute, the connection isn't doing well (proxy issue, slow network?) and can be closed.

See Also:

checkSessions(), Constant Field Values

logger

private final Log logger

clientInboundChannel

private final MessageChannel clientInboundChannel

clientOutboundChannel

private final SubscribableChannel clientOutboundChannel

protocolHandlerLookup

private final java.util.Map<java.lang.String,SubProtocolHandler> protocolHandlerLookup

protocolHandlers

private final java.util.Set<SubProtocolHandler> protocolHandlers

defaultProtocolHandler

private SubProtocolHandler defaultProtocolHandler

sessions

private final java.util.Map<java.lang.String,SubProtocolWebSocketHandler.WebSocketSessionHolder> sessions

sendTimeLimit

private int sendTimeLimit

sendBufferSizeLimit

private int sendBufferSizeLimit

lastSessionCheckTime

private volatile long lastSessionCheckTime

sessionCheckLock

private final java.util.concurrent.locks.ReentrantLock sessionCheckLock

stats

private final SubProtocolWebSocketHandler.Stats stats

lifecycleMonitor

private final java.lang.Object lifecycleMonitor

running

private volatile boolean running

Constructor Detail

SubProtocolWebSocketHandler

public SubProtocolWebSocketHandler(MessageChannel clientInboundChannel,
                                   SubscribableChannel clientOutboundChannel)

Method Detail

setProtocolHandlers

public void setProtocolHandlers(java.util.List<SubProtocolHandler> protocolHandlers)

Configure one or more handlers to use depending on the sub-protocol requested by the client in the WebSocket handshake request.

Parameters:

protocolHandlers - the sub-protocol handlers to use

getProtocolHandlers

public java.util.List<SubProtocolHandler> getProtocolHandlers()

addProtocolHandler

public void addProtocolHandler(SubProtocolHandler handler)

Register a sub-protocol handler.

getProtocolHandlerMap

public java.util.Map<java.lang.String,SubProtocolHandler> getProtocolHandlerMap()

Return the sub-protocols keyed by protocol name.

setDefaultProtocolHandler

public void setDefaultProtocolHandler(SubProtocolHandler defaultProtocolHandler)

Set the SubProtocolHandler to use when the client did not request a sub-protocol.

Parameters:

defaultProtocolHandler - the default handler

getDefaultProtocolHandler

public SubProtocolHandler getDefaultProtocolHandler()

Returns:

the default sub-protocol handler to use

getSubProtocols

public java.util.List<java.lang.String> getSubProtocols()

Return all supported protocols.

Specified by:

getSubProtocols in interface SubProtocolCapable

setSendTimeLimit

public void setSendTimeLimit(int sendTimeLimit)

getSendTimeLimit

public int getSendTimeLimit()

setSendBufferSizeLimit

public void setSendBufferSizeLimit(int sendBufferSizeLimit)

getSendBufferSizeLimit

public int getSendBufferSizeLimit()

isAutoStartup

public boolean isAutoStartup()

Description copied from interface: SmartLifecycle

Returns true if this Lifecycle component should get started automatically by the container at the time that the containing ApplicationContext gets refreshed.

A value of false indicates that the component is intended to be started through an explicit Lifecycle.start() call instead, analogous to a plain Lifecycle implementation.

Specified by:

isAutoStartup in interface SmartLifecycle

See Also:

Lifecycle.start(), Phased.getPhase(), LifecycleProcessor.onRefresh(), ConfigurableApplicationContext.refresh()

getPhase

public int getPhase()

Description copied from interface: Phased

Return the phase value of this object.

Specified by:

getPhase in interface Phased

isRunning

public final boolean isRunning()

Description copied from interface: Lifecycle

Check whether this component is currently running.

In the case of a container, this will return true only if all components that apply are currently running.

Specified by:

isRunning in interface Lifecycle

Returns:

whether the component is currently running

getStatsInfo

public java.lang.String getStatsInfo()

Return a String describing internal state and counters.

start

public final void start()

Description copied from interface: Lifecycle

Start this component.

Should not throw an exception if the component is already running.

In the case of a container, this will propagate the start signal to all components that apply.

Specified by:

start in interface Lifecycle

See Also:

SmartLifecycle.isAutoStartup()

stop

public final void stop()

Description copied from interface: Lifecycle

Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method. Consider implementing SmartLifecycle and its stop(Runnable) variant when asynchronous stop behavior is necessary.

Note that this stop notification is not guaranteed to come before destruction: On regular shutdown, Lifecycle beans will first receive a stop notification before the general destruction callbacks are being propagated; however, on hot refresh during a context's lifetime or on aborted refresh attempts, only destroy methods will be called.

Should not throw an exception if the component isn't started yet.

In the case of a container, this will propagate the stop signal to all components that apply.

Specified by:

stop in interface Lifecycle

See Also:

SmartLifecycle.stop(Runnable), DisposableBean.destroy()

stop

public final void stop(java.lang.Runnable callback)

Description copied from interface: SmartLifecycle

Indicates that a Lifecycle component must stop if it is currently running.

The provided callback is used by the LifecycleProcessor to support an ordered, and potentially concurrent, shutdown of all components having a common shutdown order value. The callback must be executed after the SmartLifecycle component does indeed stop.

The LifecycleProcessor will call only this variant of the stop method; i.e. Lifecycle.stop() will not be called for SmartLifecycle implementations unless explicitly delegated to within the implementation of this method.

Specified by:

stop in interface SmartLifecycle

See Also:

Lifecycle.stop(), Phased.getPhase()

afterConnectionEstablished

public void afterConnectionEstablished(WebSocketSession session)
                                throws java.lang.Exception

Description copied from interface: WebSocketHandler

Invoked after WebSocket negotiation has succeeded and the WebSocket connection is opened and ready for use.

Specified by:

afterConnectionEstablished in interface WebSocketHandler

Throws:

java.lang.Exception - this method can handle or propagate exceptions; see class-level Javadoc for details.

findProtocolHandler

protected final SubProtocolHandler findProtocolHandler(WebSocketSession session)

handleMessage

public void handleMessage(WebSocketSession session,
                          WebSocketMessage<?> message)
                   throws java.lang.Exception

Handle an inbound message from a WebSocket client.

Specified by:

handleMessage in interface WebSocketHandler

Throws:

java.lang.Exception - this method can handle or propagate exceptions; see class-level Javadoc for details.

handleMessage

public void handleMessage(Message<?> message)
                   throws MessagingException

Handle an outbound Spring Message to a WebSocket client.

Specified by:

handleMessage in interface MessageHandler

Parameters:

message - the message to be handled

Throws:

MessagingException

resolveSessionId

private java.lang.String resolveSessionId(Message<?> message)

checkSessions

private void checkSessions()
                    throws java.io.IOException

When a session is connected through a higher-level protocol it has a chance to use heartbeat management to shut down sessions that are too slow to send or receive messages. However, after a WebSocketSession is established and before the higher level protocol is fully connected there is a possibility for sessions to hang. This method checks and closes any sessions that have been connected for more than 60 seconds without having received a single message.

Throws:

java.io.IOException

handleTransportError

public void handleTransportError(WebSocketSession session,
                                 java.lang.Throwable exception)
                          throws java.lang.Exception

Description copied from interface: WebSocketHandler

Handle an error from the underlying WebSocket message transport.

Specified by:

handleTransportError in interface WebSocketHandler

Throws:

java.lang.Exception - this method can handle or propagate exceptions; see class-level Javadoc for details.

afterConnectionClosed

public void afterConnectionClosed(WebSocketSession session,
                                  CloseStatus closeStatus)
                           throws java.lang.Exception

Description copied from interface: WebSocketHandler

Invoked after the WebSocket connection has been closed by either side, or after a transport error has occurred. Although the session may technically still be open, depending on the underlying implementation, sending messages at this point is discouraged and most likely will not succeed.

Specified by:

afterConnectionClosed in interface WebSocketHandler

Throws:

java.lang.Exception - this method can handle or propagate exceptions; see class-level Javadoc for details.

clearSession

private void clearSession(WebSocketSession session,
                          CloseStatus closeStatus)
                   throws java.lang.Exception

Throws:

java.lang.Exception

supportsPartialMessages

public boolean supportsPartialMessages()

Description copied from interface: WebSocketHandler

Whether the WebSocketHandler handles partial messages. If this flag is set to true and the underlying WebSocket server supports partial messages, then a large WebSocket message, or one of an unknown size may be split and maybe received over multiple calls to WebSocketHandler.handleMessage(WebSocketSession, WebSocketMessage). The flag WebSocketMessage.isLast() indicates if the message is partial and whether it is the last part.

Specified by:

supportsPartialMessages in interface WebSocketHandler

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object