java.lang.Object
- org.springframework.messaging.simp.stomp.StompClientSupport
- - org.springframework.web.socket.messaging.WebSocketStompClient

All Implemented Interfaces:
Lifecycle, Phased, SmartLifecycle
```
public class WebSocketStompClient
extends StompClientSupport
implements SmartLifecycle
```
A STOMP over WebSocket client that connects using an implementation of WebSocketClient including SockJsClient.
Since:
4.2
Author:
Rossen Stoyanchev

Constructor Summary
Constructors
Constructor Description
WebSocketStompClient(WebSocketClient webSocketClient)
Class constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`ListenableFuture<StompSession>`	`connect(String url, StompSessionHandler handler, Object... uriVars)`	Connect to the given WebSocket URL and notify the given `StompSessionHandler` when connected on the STOMP level after the CONNECTED frame is received.
`ListenableFuture<StompSession>`	`connect(String url, WebSocketHttpHeaders handshakeHeaders, StompHeaders connectHeaders, StompSessionHandler handler, Object... uriVariables)`	An overloaded version of `connect(String, StompSessionHandler, Object...)` that also accepts `WebSocketHttpHeaders` to use for the WebSocket handshake and `StompHeaders` for the STOMP CONNECT frame.
`ListenableFuture<StompSession>`	`connect(String url, WebSocketHttpHeaders handshakeHeaders, StompSessionHandler handler, Object... uriVariables)`	An overloaded version of `connect(String, StompSessionHandler, Object...)` that also accepts `WebSocketHttpHeaders` to use for the WebSocket handshake.
`ListenableFuture<StompSession>`	`connect(URI url, WebSocketHttpHeaders handshakeHeaders, StompHeaders connectHeaders, StompSessionHandler sessionHandler)`	An overloaded version of `connect(String, WebSocketHttpHeaders, StompSessionHandler, Object...)` that accepts a fully prepared `URI`.
`int`	`getInboundMessageSizeLimit()`	Get the configured inbound message buffer size in bytes.
`int`	`getPhase()`	Return the configured phase.
`WebSocketClient`	`getWebSocketClient()`	Return the configured WebSocketClient.
`boolean`	`isAutoStartup()`	Return the value for the 'autoStartup' property.
`boolean`	`isRunning()`	Check whether this component is currently running.
`protected StompHeaders`	`processConnectHeaders(StompHeaders connectHeaders)`	Further initialize the StompHeaders, for example setting the heart-beat header if necessary.
`void`	`setAutoStartup(boolean autoStartup)`	Set whether to auto-start the contained WebSocketClient when the Spring context has been refreshed.
`void`	`setInboundMessageSizeLimit(int inboundMessageSizeLimit)`	Configure the maximum size allowed for inbound STOMP message.
`void`	`setPhase(int phase)`	Specify the phase in which the WebSocket client should be started and subsequently closed.
`void`	`setTaskScheduler(TaskScheduler taskScheduler)`	Configure a scheduler to use for heartbeats and for receipt tracking.
`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(Runnable callback)`	Indicates that a Lifecycle component must stop if it is currently running.

Methods inherited from class org.springframework.messaging.simp.stomp.StompClientSupport
createSession, getDefaultHeartbeat, getMessageConverter, getReceiptTimeLimit, getTaskScheduler, isDefaultHeartbeatEnabled, setDefaultHeartbeat, setMessageConverter, setReceiptTimeLimit

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - WebSocketStompClient
```
public WebSocketStompClient(WebSocketClient webSocketClient)
```
    Class constructor. Sets StompClientSupport.setDefaultHeartbeat(long[]) to "0,0" but will reset it back to the preferred "10000,10000" when a setTaskScheduler(org.springframework.scheduling.TaskScheduler) is configured.
    Parameters:
    webSocketClient - the WebSocket client to connect with
- Method Detail
  - getWebSocketClient
```
public WebSocketClient getWebSocketClient()
```
    Return the configured WebSocketClient.
  - setTaskScheduler
```
public void setTaskScheduler(TaskScheduler taskScheduler)
```
    Configure a scheduler to use for heartbeats and for receipt tracking.
    Note: Some transports have built-in support to work with heartbeats and therefore do not require a TaskScheduler. Receipts however, if needed, do require a TaskScheduler to be configured.
    By default, this is not set.
    Also automatically sets the defaultHeartbeat property to "10000,10000" if it is currently set to "0,0".
    Overrides:
    setTaskScheduler in class StompClientSupport
  - setInboundMessageSizeLimit
```
public void setInboundMessageSizeLimit(int inboundMessageSizeLimit)
```
    Configure the maximum size allowed for inbound STOMP message. Since a STOMP message can be received in multiple WebSocket messages, buffering may be required and this property determines the maximum buffer size per message.
    By default this is set to 64 * 1024 (64K).
  - getInboundMessageSizeLimit
```
public int getInboundMessageSizeLimit()
```
    Get the configured inbound message buffer size in bytes.
  - setAutoStartup
```
public void setAutoStartup(boolean autoStartup)
```
    Set whether to auto-start the contained WebSocketClient when the Spring context has been refreshed.
    Default is "true".
  - isAutoStartup
```
public boolean isAutoStartup()
```
    Return the value for the 'autoStartup' property. If "true", this client will automatically start and stop the contained WebSocketClient.
    Specified by:
    isAutoStartup in interface SmartLifecycle
    See Also:
    Lifecycle.start(), Phased.getPhase(), LifecycleProcessor.onRefresh(), ConfigurableApplicationContext.refresh()
  - setPhase
```
public void setPhase(int phase)
```
    Specify the phase in which the WebSocket client should be started and subsequently closed. The startup order proceeds from lowest to highest, and the shutdown order is the reverse of that.
    By default this is Integer.MAX_VALUE meaning that the WebSocket client is started as late as possible and stopped as soon as possible.
  - getPhase
```
public int getPhase()
```
    Return the configured phase.
    Specified by:
    getPhase in interface Phased
  - start
```
public 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 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, a given bean's destroy method will be called without any consideration of stop signals upfront.
    Should not throw an exception if the component is not running (not 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 void stop(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()
  - isRunning
```
public 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
  - connect
```
public ListenableFuture<StompSession> connect(String url,
                                              StompSessionHandler handler,
                                              Object... uriVars)
```
    Connect to the given WebSocket URL and notify the given StompSessionHandler when connected on the STOMP level after the CONNECTED frame is received.
    Parameters:
    url - the url to connect to
    handler - the session handler
    uriVars - the URI variables to expand into the URL
    Returns:
    a ListenableFuture for access to the session when ready for use
  - connect
```
public ListenableFuture<StompSession> connect(String url,
                                              WebSocketHttpHeaders handshakeHeaders,
                                              StompSessionHandler handler,
                                              Object... uriVariables)
```
    An overloaded version of connect(String, StompSessionHandler, Object...) that also accepts WebSocketHttpHeaders to use for the WebSocket handshake.
    Parameters:
    url - the url to connect to
    handshakeHeaders - the headers for the WebSocket handshake
    handler - the session handler
    uriVariables - the URI variables to expand into the URL
    Returns:
    a ListenableFuture for access to the session when ready for use
  - connect
```
public ListenableFuture<StompSession> connect(String url,
                                              WebSocketHttpHeaders handshakeHeaders,
                                              StompHeaders connectHeaders,
                                              StompSessionHandler handler,
                                              Object... uriVariables)
```
    An overloaded version of connect(String, StompSessionHandler, Object...) that also accepts WebSocketHttpHeaders to use for the WebSocket handshake and StompHeaders for the STOMP CONNECT frame.
    Parameters:
    url - the url to connect to
    handshakeHeaders - headers for the WebSocket handshake
    connectHeaders - headers for the STOMP CONNECT frame
    handler - the session handler
    uriVariables - the URI variables to expand into the URL
    Returns:
    a ListenableFuture for access to the session when ready for use
  - connect
```
public ListenableFuture<StompSession> connect(URI url,
                                              WebSocketHttpHeaders handshakeHeaders,
                                              StompHeaders connectHeaders,
                                              StompSessionHandler sessionHandler)
```
    An overloaded version of connect(String, WebSocketHttpHeaders, StompSessionHandler, Object...) that accepts a fully prepared URI.
    Parameters:
    url - the url to connect to
    handshakeHeaders - the headers for the WebSocket handshake
    connectHeaders - headers for the STOMP CONNECT frame
    sessionHandler - the STOMP session handler
    Returns:
    a ListenableFuture for access to the session when ready for use
  - processConnectHeaders
```
protected StompHeaders processConnectHeaders(StompHeaders connectHeaders)
```
    Description copied from class: StompClientSupport
    Further initialize the StompHeaders, for example setting the heart-beat header if necessary.
    Overrides:
    processConnectHeaders in class StompClientSupport
    Parameters:
    connectHeaders - the headers to modify
    Returns:
    the modified headers

Class WebSocketStompClient

Constructor Summary

Method Summary

Methods inherited from class org.springframework.messaging.simp.stomp.StompClientSupport

Methods inherited from class java.lang.Object

Constructor Detail

WebSocketStompClient

Method Detail

getWebSocketClient

setTaskScheduler

setInboundMessageSizeLimit

getInboundMessageSizeLimit

setAutoStartup

isAutoStartup

setPhase

getPhase

start

stop

stop

isRunning

connect

connect

connect

connect

processConnectHeaders