org.springframework.web.socket.sockjs.transport.handler

## Class WebSocketTransportHandler

- java.lang.Object
- - org.springframework.web.socket.sockjs.transport.handler.AbstractTransportHandler
  - - org.springframework.web.socket.sockjs.transport.handler.WebSocketTransportHandler

- All Implemented Interfaces:
    Aware, Lifecycle, ServletContextAware, HandshakeHandler, SockJsSessionFactory, TransportHandler

      public class WebSocketTransportHandler
      extends AbstractTransportHandler
      implements SockJsSessionFactory, HandshakeHandler, Lifecycle, ServletContextAware

  WebSocket-based `TransportHandler`. Uses `SockJsWebSocketHandler` and `WebSocketServerSockJsSession` to add SockJS processing.

  Also implements `HandshakeHandler` to support raw WebSocket communication at SockJS URL "/websocket".

  Since:
    4.0
  Author:
    Rossen Stoyanchev

- - ### Field Summary

    - ### Fields inherited from class org.springframework.web.socket.sockjs.transport.handler.AbstractTransportHandler

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `WebSocketTransportHandler(HandshakeHandler handshakeHandler)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `checkSessionType(SockJsSession session)` Check whether the type of the given session matches the transport type of this `TransportHandler` where session id and the transport type are extracted from the SockJS URL.
    `AbstractSockJsSession` | `createSession(String id, WebSocketHandler handler, Map<String,Object> attrs)` Create a new SockJS session.
    `boolean` | `doHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler handler, Map<String,Object> attributes)` Initiate the handshake.
    `HandshakeHandler` | `getHandshakeHandler()`
    `TransportType` | `getTransportType()` Return the transport type supported by this handler.
    `void` | `handleRequest(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, SockJsSession wsSession)` Handle the given request and delegate messages to the provided `WebSocketHandler`.
    `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.

    - ### Methods inherited from class org.springframework.web.socket.sockjs.transport.handler.AbstractTransportHandler

      `getServiceConfig, initialize`

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

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

- - ### Constructor Detail

    - #### WebSocketTransportHandler

          public WebSocketTransportHandler(HandshakeHandler handshakeHandler)

  - ### Method Detail

    - #### getTransportType

          public TransportType getTransportType()

      Description copied from interface: `TransportHandler`
      Return the transport type supported by this handler.
      Specified by:
        `getTransportType` in interface `TransportHandler`

    - #### getHandshakeHandler

          public HandshakeHandler getHandshakeHandler()

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

    - #### checkSessionType

          public boolean checkSessionType(SockJsSession session)

      Description copied from interface: `TransportHandler`
      Check whether the type of the given session matches the transport type of this `TransportHandler` where session id and the transport type are extracted from the SockJS URL.
      Specified by:
        `checkSessionType` in interface `TransportHandler`
      Returns:
        `true` if the session matches (and would therefore get accepted by `TransportHandler.handleRequest(org.springframework.http.server.ServerHttpRequest, org.springframework.http.server.ServerHttpResponse, org.springframework.web.socket.WebSocketHandler, org.springframework.web.socket.sockjs.transport.SockJsSession)`), or `false` otherwise

    - #### createSession

          public AbstractSockJsSession createSession(String id,
                                                     WebSocketHandler handler,
                                                     Map<String,Object> attrs)

      Description copied from interface: `SockJsSessionFactory`
      Create a new SockJS session.
      Specified by:
        `createSession` in interface `SockJsSessionFactory`
      Parameters:
        `id` - the ID of the session
        `handler` - the underlying `WebSocketHandler`
        `attrs` - handshake request specific attributes
      Returns:
        a new session, never `null`

    - #### handleRequest

          public void handleRequest(ServerHttpRequest request,
                                    ServerHttpResponse response,
                                    WebSocketHandler wsHandler,
                                    SockJsSession wsSession)
                             throws SockJsException

      Description copied from interface: `TransportHandler`
      Handle the given request and delegate messages to the provided `WebSocketHandler`.
      Specified by:
        `handleRequest` in interface `TransportHandler`
      Parameters:
        `request` - the current request
        `response` - the current response
        `wsHandler` - the target WebSocketHandler (never `null`)
        `wsSession` - the SockJS session (never `null`)
      Throws:
        `SockJsException` - raised when request processing fails as explained in `SockJsService`

    - #### doHandshake

          public boolean doHandshake(ServerHttpRequest request,
                                     ServerHttpResponse response,
                                     WebSocketHandler handler,
                                     Map<String,Object> attributes)
                              throws HandshakeFailureException

      Description copied from interface: `HandshakeHandler`
      Initiate the handshake.
      Specified by:
        `doHandshake` in interface `HandshakeHandler`
      Parameters:
        `request` - the current request
        `response` - the current response
        `handler` - the handler to process WebSocket messages; see `PerConnectionWebSocketHandler` for providing a handler with per-connection lifecycle.
        `attributes` - the attributes from the HTTP handshake to associate with the WebSocket session; the provided attributes are copied, the original map is not used.
      Returns:
        whether the handshake negotiation was successful or not. In either case the response status, headers, and body will have been updated to reflect the result of the negotiation
      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 handshake.