org.springframework.web.socket.sockjs.transport.session

Class AbstractHttpSockJsSession

java.lang.Object

org.springframework.web.socket.sockjs.transport.session.AbstractSockJsSession

org.springframework.web.socket.sockjs.transport.session.AbstractHttpSockJsSession

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable, SockJsSession, WebSocketSession

Direct Known Subclasses:

PollingSockJsSession, StreamingSockJsSession

public abstract class AbstractHttpSockJsSession
extends AbstractSockJsSession

An abstract base class for use with HTTP transport SockJS sessions.

Since:

4.0

Author:

Rossen Stoyanchev

Field Summary

Fields

Modifier and Type	Field and Description
private java.lang.String	acceptedProtocol
private ServerHttpAsyncRequestControl	asyncRequestControl
private SockJsFrameFormat	frameFormat
private HttpHeaders	handshakeHeaders
private java.net.InetSocketAddress	localAddress
private java.util.Queue<java.lang.String>	messageCache
private java.security.Principal	principal
private boolean	readyToSend
private java.net.InetSocketAddress	remoteAddress
private ServerHttpResponse	response
private java.lang.Object	responseLock
private java.net.URI	uri

Fields inherited from class org.springframework.web.socket.sockjs.transport.session.AbstractSockJsSession

DISCONNECTED_CLIENT_LOG_CATEGORY, disconnectedClientLogger, logger

Constructor Summary

Constructors

Constructor and Description
AbstractHttpSockJsSession(java.lang.String id, SockJsServiceConfig config, WebSocketHandler wsHandler, java.util.Map<java.lang.String,java.lang.Object> attributes)

Method Summary

Modifier and Type	Method and Description
private void	disableShallowEtagHeaderFilter(ServerHttpRequest request)
protected void	disconnect(CloseStatus status) Actually close the underlying WebSocket session or in the case of HTTP transports complete the underlying request.
protected abstract void	flushCache() Called when the connection is active and ready to write to the response.
java.lang.String	getAcceptedProtocol() Return the selected sub-protocol to use.
int	getBinaryMessageSizeLimit() Get the configured maximum size for an incoming binary message.
java.util.List<WebSocketExtension>	getExtensions() Return the negotiated extensions or null if none was specified or negotiated successfully.
HttpHeaders	getHandshakeHeaders() Return the headers used in the handshake request.
java.net.InetSocketAddress	getLocalAddress() Return the address on which the request was received.
protected java.util.Queue<java.lang.String>	getMessageCache() Return the SockJS buffer for messages stored transparently between polling requests.
java.security.Principal	getPrincipal() Return a Principal instance containing the name of the authenticated user.
java.net.InetSocketAddress	getRemoteAddress() Return the address of the remote client.
int	getTextMessageSizeLimit() Get the configured maximum size for an incoming text message.
java.net.URI	getUri() Return the URI used to open the WebSocket connection.
void	handleInitialRequest(ServerHttpRequest request, ServerHttpResponse response, SockJsFrameFormat frameFormat) Handle the first request for receiving messages on a SockJS HTTP transport based session.
protected abstract void	handleRequestInternal(ServerHttpRequest request, ServerHttpResponse response, boolean initialRequest) Invoked when a SockJS transport request is received.
void	handleSuccessiveRequest(ServerHttpRequest request, ServerHttpResponse response, SockJsFrameFormat frameFormat) Handle all requests, except the first one, to receive messages on a SockJS HTTP transport based session.
boolean	isActive() Polling and Streaming sessions periodically close the current HTTP request and wait for the next request to come through.
protected abstract boolean	isStreaming() Deprecated. as of 4.2, since this method is no longer used.
protected void	resetRequest()
protected void	sendMessageInternal(java.lang.String message)
void	setAcceptedProtocol(java.lang.String protocol) Unlike WebSocket where sub-protocol negotiation is part of the initial handshake, in HTTP transports the same negotiation must be emulated and the selected protocol set through this setter.
void	setBinaryMessageSizeLimit(int messageSizeLimit) Configure the maximum size for an incoming binary message.
void	setTextMessageSizeLimit(int messageSizeLimit) Configure the maximum size for an incoming text message.
protected void	writeFrameInternal(SockJsFrame frame)
protected void	writePrelude(ServerHttpRequest request, ServerHttpResponse response) Deprecated. as of 4.2 this method is deprecated since the prelude is written in handleRequestInternal(org.springframework.http.server.ServerHttpRequest, org.springframework.http.server.ServerHttpResponse, boolean) of the StreamingSockJsSession subclass.

Methods inherited from class org.springframework.web.socket.sockjs.transport.session.AbstractSockJsSession

cancelHeartbeat, close, close, delegateConnectionClosed, delegateConnectionEstablished, delegateError, delegateMessages, disableHeartbeat, getAttributes, getId, getMessageCodec, getSockJsServiceConfig, getTimeSinceLastActive, isClosed, isNew, isOpen, scheduleHeartbeat, sendHeartbeat, sendMessage, toString, tryCloseWithSockJsTransportError, updateLastActiveTime, writeFrame

Methods inherited from class java.lang.Object

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

Field Detail

uri

private volatile java.net.URI uri

handshakeHeaders

private volatile HttpHeaders handshakeHeaders

principal

private volatile java.security.Principal principal

localAddress

private volatile java.net.InetSocketAddress localAddress

remoteAddress

private volatile java.net.InetSocketAddress remoteAddress

acceptedProtocol

private volatile java.lang.String acceptedProtocol

response

private volatile ServerHttpResponse response

frameFormat

private volatile SockJsFrameFormat frameFormat

asyncRequestControl

private volatile ServerHttpAsyncRequestControl asyncRequestControl

responseLock

private final java.lang.Object responseLock

readyToSend

private volatile boolean readyToSend

messageCache

private final java.util.Queue<java.lang.String> messageCache

Constructor Detail

AbstractHttpSockJsSession

public AbstractHttpSockJsSession(java.lang.String id,
                                 SockJsServiceConfig config,
                                 WebSocketHandler wsHandler,
                                 java.util.Map<java.lang.String,java.lang.Object> attributes)

Method Detail

getUri

public java.net.URI getUri()

Description copied from interface: WebSocketSession

Return the URI used to open the WebSocket connection.

getHandshakeHeaders

public HttpHeaders getHandshakeHeaders()

Description copied from interface: WebSocketSession

Return the headers used in the handshake request.

getPrincipal

public java.security.Principal getPrincipal()

Description copied from interface: WebSocketSession

Return a Principal instance containing the name of the authenticated user.

If the user has not been authenticated, the method returns null.

getLocalAddress

public java.net.InetSocketAddress getLocalAddress()

Description copied from interface: WebSocketSession

Return the address on which the request was received.

getRemoteAddress

public java.net.InetSocketAddress getRemoteAddress()

Description copied from interface: WebSocketSession

Return the address of the remote client.

setAcceptedProtocol

public void setAcceptedProtocol(java.lang.String protocol)

Unlike WebSocket where sub-protocol negotiation is part of the initial handshake, in HTTP transports the same negotiation must be emulated and the selected protocol set through this setter.

Parameters:

protocol - the sub-protocol to set

getAcceptedProtocol

public java.lang.String getAcceptedProtocol()

Return the selected sub-protocol to use.

getMessageCache

protected java.util.Queue<java.lang.String> getMessageCache()

Return the SockJS buffer for messages stored transparently between polling requests. If the polling request takes longer than 5 seconds, the session is closed.

See Also:

TransportHandlingSockJsService

isActive

public boolean isActive()

Description copied from class: AbstractSockJsSession

Polling and Streaming sessions periodically close the current HTTP request and wait for the next request to come through. During this "downtime" the session is still open but inactive and unable to send messages and therefore has to buffer them temporarily. A WebSocket session by contrast is stateful and remain active until closed.

Specified by:

isActive in class AbstractSockJsSession

setTextMessageSizeLimit

public void setTextMessageSizeLimit(int messageSizeLimit)

Description copied from interface: WebSocketSession

Configure the maximum size for an incoming text message.

getTextMessageSizeLimit

public int getTextMessageSizeLimit()

Description copied from interface: WebSocketSession

Get the configured maximum size for an incoming text message.

setBinaryMessageSizeLimit

public void setBinaryMessageSizeLimit(int messageSizeLimit)

Description copied from interface: WebSocketSession

Configure the maximum size for an incoming binary message.

getBinaryMessageSizeLimit

public int getBinaryMessageSizeLimit()

Description copied from interface: WebSocketSession

Get the configured maximum size for an incoming binary message.

getExtensions

public java.util.List<WebSocketExtension> getExtensions()

Description copied from interface: WebSocketSession

Return the negotiated extensions or null if none was specified or negotiated successfully.

isStreaming

@Deprecated
protected abstract boolean isStreaming()

Deprecated. as of 4.2, since this method is no longer used.

handleInitialRequest

public void handleInitialRequest(ServerHttpRequest request,
                                 ServerHttpResponse response,
                                 SockJsFrameFormat frameFormat)
                          throws SockJsException

Handle the first request for receiving messages on a SockJS HTTP transport based session.

Long polling-based transports (e.g. "xhr", "jsonp") complete the request after writing the open frame. Streaming-based transports ("xhr_streaming", "eventsource", and "htmlfile") leave the response open longer for further streaming of message frames but will also close it eventually after some amount of data has been sent.

Parameters:

request - the current request

response - the current response

frameFormat - the transport-specific SocksJS frame format to use

Throws:

SockJsException

handleSuccessiveRequest

public void handleSuccessiveRequest(ServerHttpRequest request,
                                    ServerHttpResponse response,
                                    SockJsFrameFormat frameFormat)
                             throws SockJsException

Handle all requests, except the first one, to receive messages on a SockJS HTTP transport based session.

Long polling-based transports (e.g. "xhr", "jsonp") complete the request after writing any buffered message frames (or the next one). Streaming-based transports ("xhr_streaming", "eventsource", and "htmlfile") leave the response open longer for further streaming of message frames but will also close it eventually after some amount of data has been sent.

Parameters:

request - the current request

response - the current response

frameFormat - the transport-specific SocksJS frame format to use

Throws:

SockJsException

disableShallowEtagHeaderFilter

private void disableShallowEtagHeaderFilter(ServerHttpRequest request)

handleRequestInternal

protected abstract void handleRequestInternal(ServerHttpRequest request,
                                              ServerHttpResponse response,
                                              boolean initialRequest)
                                       throws java.io.IOException

Invoked when a SockJS transport request is received.

Parameters:

request - the current request

response - the current response

initialRequest - whether it is the first request for the session

Throws:

java.io.IOException

sendMessageInternal

protected final void sendMessageInternal(java.lang.String message)
                                  throws SockJsTransportFailureException

Specified by:

sendMessageInternal in class AbstractSockJsSession

Throws:

SockJsTransportFailureException

flushCache

protected abstract void flushCache()
                            throws SockJsTransportFailureException

Called when the connection is active and ready to write to the response. Subclasses should only call this method from a method where the "responseLock" is acquired.

Throws:

SockJsTransportFailureException

writePrelude

@Deprecated
protected void writePrelude(ServerHttpRequest request,
                                        ServerHttpResponse response)
                                 throws java.io.IOException

Deprecated. as of 4.2 this method is deprecated since the prelude is written in handleRequestInternal(org.springframework.http.server.ServerHttpRequest, org.springframework.http.server.ServerHttpResponse, boolean) of the StreamingSockJsSession subclass.

Throws:

java.io.IOException

disconnect

protected void disconnect(CloseStatus status)

Description copied from class: AbstractSockJsSession

Actually close the underlying WebSocket session or in the case of HTTP transports complete the underlying request.

Specified by:

disconnect in class AbstractSockJsSession

resetRequest

protected void resetRequest()

writeFrameInternal

protected void writeFrameInternal(SockJsFrame frame)
                           throws java.io.IOException

Specified by:

writeFrameInternal in class AbstractSockJsSession

Throws:

java.io.IOException