org.springframework.web.socket.client.jetty

## Class JettyWebSocketClient

- java.lang.Object
- - org.springframework.web.socket.client.AbstractWebSocketClient
  - - org.springframework.web.socket.client.jetty.JettyWebSocketClient

- All Implemented Interfaces:
    Lifecycle, WebSocketClient

      public class JettyWebSocketClient
      extends AbstractWebSocketClient
      implements Lifecycle

  Initiates WebSocket requests to a WebSocket server programmatically through the Jetty WebSocket API.

  As of 4.1 this class implements `Lifecycle` rather than `SmartLifecycle`. Use `WebSocketConnectionManager` instead to auto-start a WebSocket connection.

  Since:
    4.0
  Author:
    Rossen Stoyanchev

- - ### Field Summary

    - ### Fields inherited from class org.springframework.web.socket.client.AbstractWebSocketClient

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `JettyWebSocketClient()` Default constructor that creates an instance of `WebSocketClient`.
    `JettyWebSocketClient(org.eclipse.jetty.websocket.client.WebSocketClient client)` Constructor that accepts an existing `WebSocketClient` instance.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `ListenableFuture<WebSocketSession>` | `doHandshake(WebSocketHandler webSocketHandler, String uriTemplate, Object... uriVars)`
    `ListenableFuture<WebSocketSession>` | `doHandshakeInternal(WebSocketHandler wsHandler, HttpHeaders headers, URI uri, List<String> protocols, List<WebSocketExtension> extensions, Map<String,Object> attributes)` Perform the actual handshake to establish a connection to the server.
    `AsyncListenableTaskExecutor` | `getTaskExecutor()` Return the configured `TaskExecutor`.
    `protected Principal` | `getUser()` Return the user to make available through `WebSocketSession.getPrincipal()`.
    `boolean` | `isRunning()` Check whether this component is currently running.
    `void` | `setTaskExecutor(AsyncListenableTaskExecutor taskExecutor)` Set an `AsyncListenableTaskExecutor` to use when opening connections.
    `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.

    - ### Methods inherited from class org.springframework.web.socket.client.AbstractWebSocketClient

      `assertUri, doHandshake`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### JettyWebSocketClient

          public JettyWebSocketClient()

      Default constructor that creates an instance of `WebSocketClient`.

    - #### JettyWebSocketClient

          public JettyWebSocketClient(org.eclipse.jetty.websocket.client.WebSocketClient client)

      Constructor that accepts an existing `WebSocketClient` instance.

  - ### Method Detail

    - #### setTaskExecutor

          public void setTaskExecutor(@Nullable
                                      AsyncListenableTaskExecutor taskExecutor)

      Set an `AsyncListenableTaskExecutor` to use when opening connections. If this property is set to `null`, calls to any of the `doHandshake` methods will block until the connection is established.

      By default an instance of `SimpleAsyncTaskExecutor` is used.

    - #### getTaskExecutor

          @Nullable
          public AsyncListenableTaskExecutor getTaskExecutor()

      Return the configured `TaskExecutor`.

    - #### 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()`

    - #### 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

    - #### doHandshake

          public ListenableFuture<WebSocketSession> doHandshake(WebSocketHandler webSocketHandler,
                                                                String uriTemplate,
                                                                Object... uriVars)

      Specified by:
        `doHandshake` in interface `WebSocketClient`
      Overrides:
        `doHandshake` in class `AbstractWebSocketClient`

    - #### doHandshakeInternal

          public ListenableFuture<WebSocketSession> doHandshakeInternal(WebSocketHandler wsHandler,
                                                                        HttpHeaders headers,
                                                                        URI uri,
                                                                        List<String> protocols,
                                                                        List<WebSocketExtension> extensions,
                                                                        Map<String,Object> attributes)

      Description copied from class: `AbstractWebSocketClient`
      Perform the actual handshake to establish a connection to the server.
      Specified by:
        `doHandshakeInternal` in class `AbstractWebSocketClient`
      Parameters:
        `wsHandler` - the client-side handler for WebSocket messages
        `headers` - the HTTP headers to use for the handshake, with unwanted (forbidden) headers filtered out (never `null`)
        `uri` - the target URI for the handshake (never `null`)
        `protocols` - requested sub-protocols, or an empty list
        `extensions` - requested WebSocket extensions, or an empty list
        `attributes` - the attributes to associate with the WebSocketSession, i.e. via `WebSocketSession.getAttributes()`; currently always an empty map.
      Returns:
        the established WebSocket session wrapped in a ListenableFuture.

    - #### getUser

          @Nullable
          protected Principal getUser()

      Return the user to make available through `WebSocketSession.getPrincipal()`. By default, this method returns `null`