org.springframework.web.socket.server.jetty

## Class JettyRequestUpgradeStrategy

- java.lang.Object
- - org.springframework.web.socket.server.jetty.JettyRequestUpgradeStrategy

- All Implemented Interfaces:
    Aware, Lifecycle, ServletContextAware, RequestUpgradeStrategy

      public class JettyRequestUpgradeStrategy
      extends Object
      implements RequestUpgradeStrategy, ServletContextAware, Lifecycle

  A `RequestUpgradeStrategy` for use with Jetty 9.4. Based on Jetty's internal `org.eclipse.jetty.websocket.server.WebSocketHandler` class.
  Since:
    4.0
  Author:
    Phillip Webb, Rossen Stoyanchev, Brian Clozel, Juergen Hoeller

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `JettyRequestUpgradeStrategy()` Default constructor that creates `WebSocketServerFactory` through its default constructor thus using a default `WebSocketPolicy`.
    `JettyRequestUpgradeStrategy(org.eclipse.jetty.websocket.api.WebSocketPolicy policy)` A constructor accepting a `WebSocketPolicy` to be used when creating the `WebSocketServerFactory` instance.
    `JettyRequestUpgradeStrategy(org.eclipse.jetty.websocket.server.WebSocketServerFactory factory)` A constructor accepting a `WebSocketServerFactory`.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `List<WebSocketExtension>` | `getSupportedExtensions(ServerHttpRequest request)` Return the WebSocket protocol extensions supported by the underlying WebSocket server.
    `String[]` | `getSupportedVersions()` Return the supported WebSocket protocol versions.
    `boolean` | `isRunning()` Check whether this component is currently running.
    `void` | `setServletContext(ServletContext servletContext)` Set the `ServletContext` that this object runs in.
    `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` | `upgrade(ServerHttpRequest request, ServerHttpResponse response, String selectedProtocol, List<WebSocketExtension> selectedExtensions, Principal user, WebSocketHandler wsHandler, Map<String,Object> attributes)` Perform runtime specific steps to complete the upgrade.

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

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

- - ### Constructor Detail

    - #### JettyRequestUpgradeStrategy

          public JettyRequestUpgradeStrategy()

      Default constructor that creates `WebSocketServerFactory` through its default constructor thus using a default `WebSocketPolicy`.

    - #### JettyRequestUpgradeStrategy

          public JettyRequestUpgradeStrategy(org.eclipse.jetty.websocket.api.WebSocketPolicy policy)

      A constructor accepting a `WebSocketPolicy` to be used when creating the `WebSocketServerFactory` instance.
      Parameters:
        `policy` - the policy to use
      Since:
        4.3.5

    - #### JettyRequestUpgradeStrategy

          public JettyRequestUpgradeStrategy(org.eclipse.jetty.websocket.server.WebSocketServerFactory factory)

      A constructor accepting a `WebSocketServerFactory`.
      Parameters:
        `factory` - the pre-configured factory to use

  - ### Method Detail

    - #### setServletContext

          public void setServletContext(ServletContext servletContext)

      Description copied from interface: `ServletContextAware`
      Set the `ServletContext` that this object runs in.

      Invoked after population of normal bean properties but before an init callback like InitializingBean's `afterPropertiesSet` or a custom init-method. Invoked after ApplicationContextAware's `setApplicationContext`.

      Specified by:
        `setServletContext` in interface `ServletContextAware`
      Parameters:
        `servletContext` - the ServletContext object to be used by this object
      See Also:
        `InitializingBean.afterPropertiesSet()`, `ApplicationContextAware.setApplicationContext(org.springframework.context.ApplicationContext)`

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

    - #### getSupportedVersions

          public String[] getSupportedVersions()

      Description copied from interface: `RequestUpgradeStrategy`
      Return the supported WebSocket protocol versions.
      Specified by:
        `getSupportedVersions` in interface `RequestUpgradeStrategy`

    - #### getSupportedExtensions

          public List<WebSocketExtension> getSupportedExtensions(ServerHttpRequest request)

      Description copied from interface: `RequestUpgradeStrategy`
      Return the WebSocket protocol extensions supported by the underlying WebSocket server.
      Specified by:
        `getSupportedExtensions` in interface `RequestUpgradeStrategy`

    - #### upgrade

          public void upgrade(ServerHttpRequest request,
                              ServerHttpResponse response,
                              @Nullable
                              String selectedProtocol,
                              List<WebSocketExtension> selectedExtensions,
                              @Nullable
                              Principal user,
                              WebSocketHandler wsHandler,
                              Map<String,Object> attributes)
                       throws HandshakeFailureException

      Description copied from interface: `RequestUpgradeStrategy`
      Perform runtime specific steps to complete the upgrade. Invoked after successful negotiation of the handshake request.
      Specified by:
        `upgrade` in interface `RequestUpgradeStrategy`
      Parameters:
        `request` - the current request
        `response` - the current response
        `selectedProtocol` - the selected sub-protocol, if any
        `selectedExtensions` - the selected WebSocket protocol extensions
        `user` - the user to associate with the WebSocket session
        `wsHandler` - the handler for WebSocket messages
        `attributes` - handshake request specific attributes to be set on the WebSocket session via `HandshakeInterceptor` and thus made available to the `WebSocketHandler`
      Throws:
        `HandshakeFailureException` - thrown when handshake processing failed to complete due to an internal, unrecoverable error, i.e. a server error as opposed to a failure to successfully negotiate the requirements of the handshake request.