io.vertx.ext.stomp

## Interface StompServerHandler

- All Superinterfaces:
    Handler<ServerFrame>

      public interface StompServerHandler
      extends Handler<ServerFrame>

  STOMP server handler implements the behavior of the STOMP server when a specific event occurs. For instance, if let customize the behavior when specific STOMP frames arrives or when a connection is closed. This class has been designed to let you customize the server behavior. The default implementation is compliant with the STOMP specification. In this default implementation, not acknowledge frames are dropped.
  Author:
    Clement Escoffier

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `StompServerHandler` | `abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompServerHandler` | `ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | `authProvider(AuthProvider handler)` Configures the `AuthProvider` to be used to authenticate the user.
    `StompServerHandler` | `beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompServerHandler` | `bridge(BridgeOptions options)` Configures the STOMP server to act as a bridge with the Vert.x event bus.
    `StompServerHandler` | `closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompServerHandler` | `commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `StompServerHandler` | `connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `static StompServerHandler` | `create(Vertx vertx)` Creates an instance of `StompServerHandler` using the default (compliant) implementation.
    `StompServerHandler` | `destinationFactory(DestinationFactory factory)` Configures the `DestinationFactory` used to create `Destination` objects.
    `StompServerHandler` | `disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `Destination` | `getDestination(String destination)` Gets the destination with the given name.
    `List<Destination>` | `getDestinations()`
    `Destination` | `getOrCreateDestination(String destination)` Gets a `Destination` object if existing, or create a new one.
    `StompServerHandler` | `nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | `onAck(StompServerConnection connection, Frame subscribe, List<Frame> messages)` Method called by single message (client-individual policy) or a set of message (client policy) are acknowledged.
    `StompServerHandler` | `onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | `onAuthenticationRequest(StompServer server, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `void` | `onClose(StompServerConnection connection)` Called when the connection is closed.
    `StompServerHandler` | `onNack(StompServerConnection connection, Frame subscribe, List<Frame> messages)` Method called by single message (client-individual policy) or a set of message (client policy) are not acknowledged.
    `StompServerHandler` | `onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompServerHandler` | `pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompServerHandler` | `sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | `stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `StompServerHandler` | `subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompServerHandler` | `unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.

    - ### Methods inherited from interface io.vertx.core.Handler

      `handle`

- - ### Method Detail

    - #### create

          static StompServerHandler create(Vertx vertx)

      Creates an instance of `StompServerHandler` using the default (compliant) implementation.
      Parameters:
        `vertx` - the vert.x instance to use
      Returns:
        the created `StompServerHandler`

    - #### connectHandler

          StompServerHandler connectHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `CONNECT` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### stompHandler

          StompServerHandler stompHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `STOMP` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### subscribeHandler

          StompServerHandler subscribeHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `SUBSCRIBE` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### unsubscribeHandler

          StompServerHandler unsubscribeHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `UNSUBSCRIBE` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### sendHandler

          StompServerHandler sendHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `SEND` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### closeHandler

          StompServerHandler closeHandler(Handler<StompServerConnection> handler)

      Configures the action to execute when a connection with the client is closed.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### onClose

          void onClose(StompServerConnection connection)

      Called when the connection is closed. This method executes a default behavior and must calls the configured `closeHandler(Handler)` if any.
      Parameters:
        `connection` - the connection

    - #### commitHandler

          StompServerHandler commitHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `COMMIT` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### abortHandler

          StompServerHandler abortHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `ABORT` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### beginHandler

          StompServerHandler beginHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `BEGIN` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### disconnectHandler

          StompServerHandler disconnectHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `DISCONNECT` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### ackHandler

          StompServerHandler ackHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `ACK` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### nackHandler

          StompServerHandler nackHandler(Handler<ServerFrame> handler)

      Configures the action to execute when a `NACK` frame is received.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### onAuthenticationRequest

          StompServerHandler onAuthenticationRequest(StompServer server,
                                                     String login,
                                                     String passcode,
                                                     Handler<AsyncResult<Boolean>> handler)

      Called when the client connects to a server requiring authentication. It invokes the `AuthProvider` configured using `authProvider(AuthProvider)`.
      Parameters:
        `server` - the STOMP server.
        `login` - the login
        `passcode` - the password
        `handler` - handler receiving the authentication result
      Returns:
        the current `StompServerHandler`

    - #### authProvider

          StompServerHandler authProvider(AuthProvider handler)

      Configures the `AuthProvider` to be used to authenticate the user.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`

    - #### getDestinations

          List<Destination> getDestinations()

      Returns:
        the list of destination managed by the STOMP server. Don't forget the STOMP interprets destination as opaque Strings.

    - #### getDestination

          Destination getDestination(String destination)

      Gets the destination with the given name.
      Parameters:
        `destination` - the destination
      Returns:
        the `Destination`, `null` if not existing.

    - #### onAck

          StompServerHandler onAck(StompServerConnection connection,
                                   Frame subscribe,
                                   List<Frame> messages)

      Method called by single message (client-individual policy) or a set of message (client policy) are acknowledged. Implementations must call the handler configured using `onAckHandler(Handler)`.
      Parameters:
        `connection` - the connection
        `subscribe` - the `SUBSCRIBE` frame
        `messages` - the acknowledge messages
      Returns:
        the current `StompServerHandler`

    - #### onNack

          StompServerHandler onNack(StompServerConnection connection,
                                    Frame subscribe,
                                    List<Frame> messages)

      Method called by single message (client-individual policy) or a set of message (client policy) are not acknowledged. Not acknowledgment can result from a `NACK` frame or from a timeout (no `ACK` frame received in a given time. Implementations must call the handler configured using `onNackHandler(Handler)`.
      Parameters:
        `connection` - the connection
        `subscribe` - the `SUBSCRIBE` frame
        `messages` - the acknowledge messages
      Returns:
        the current `StompServerHandler`

    - #### onAckHandler

          StompServerHandler onAckHandler(Handler<Acknowledgement> handler)

      Configures the action to execute when messages are acknowledged.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`
      See Also:
        `onAck(StompServerConnection, Frame, List)`

    - #### onNackHandler

          StompServerHandler onNackHandler(Handler<Acknowledgement> handler)

      Configures the action to execute when messages are not acknowledged.
      Parameters:
        `handler` - the handler
      Returns:
        the current `StompServerHandler`
      See Also:
        `onNack(StompServerConnection, Frame, List)`

    - #### pingHandler

          StompServerHandler pingHandler(Handler<StompServerConnection> handler)

      Allows customizing the action to do when the server needs to send a `PING` to the client. By default it send a frame containing `EOL` (specification). However, you can customize this and send another frame. However, be aware that this may requires a custom client.

      The handler will only be called if the connection supports heartbeats.
      Parameters:
        `handler` - the action to execute when a `PING` needs to be sent.
      Returns:
        the current `StompServerHandler`

    - #### getOrCreateDestination

          Destination getOrCreateDestination(String destination)

      Gets a `Destination` object if existing, or create a new one. The creation is delegated to the `DestinationFactory`.
      Parameters:
        `destination` - the destination
      Returns:
        the `Destination` instance, may have been created.

    - #### destinationFactory

          StompServerHandler destinationFactory(DestinationFactory factory)

      Configures the `DestinationFactory` used to create `Destination` objects.
      Parameters:
        `factory` - the factory
      Returns:
        the current `StompServerHandler`.

    - #### bridge

          StompServerHandler bridge(BridgeOptions options)

      Configures the STOMP server to act as a bridge with the Vert.x event bus.
      Parameters:
        `options` - the configuration options
      Returns:
        the current `StompServerHandler`.
      See Also:
        `Vertx.eventBus()`

Copyright © 2015. All rights reserved.