Package io.vertx.core.http

## Interface HttpClientResponse

- All Superinterfaces:
    `HttpResponseHead`, `ReadStream<Buffer>`, `StreamBase`

      public interface HttpClientResponse
      extends ReadStream<Buffer>, HttpResponseHead

  Represents a client-side HTTP response.

  Vert.x provides you with one of these via the handler that was provided when creating the `HttpClientRequest` or that was set on the `HttpClientRequest` instance.

  It implements `ReadStream` so it can be used with `Pipe` to pipe data with flow control.

  Author:
    Tim Fox

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Buffer>` | `body()` | Convenience method for receiving the entire request body in one piece.
    `default HttpClientResponse` | `bodyHandler​(Handler<Buffer> bodyHandler)` | Convenience method for receiving the entire request body in one piece.
    `HttpClientResponse` | `customFrameHandler​(Handler<HttpFrame> handler)` | Set an custom frame handler.
    `Future<Void>` | `end()` | Returns a future signaling when the response has been fully received successfully or failed.
    `HttpClientResponse` | `endHandler​(Handler<Void> endHandler)` | Set an end handler.
    `HttpClientResponse` | `exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler on the read stream.
    `HttpClientResponse` | `fetch​(long amount)` | Fetch the specified `amount` of elements.
    `String` | `getTrailer​(String trailerName)` | Return the first trailer value with the specified name
    `HttpClientResponse` | `handler​(Handler<Buffer> handler)` | Set a data handler.
    `NetSocket` | `netSocket()` |
    `HttpClientResponse` | `pause()` | Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.
    `HttpClientRequest` | `request()` |
    `HttpClientResponse` | `resume()` | Resume reading, and sets the buffer in `flowing` mode.
    `HttpClientResponse` | `streamPriorityHandler​(Handler<StreamPriority> handler)` | Set an handler for stream priority changes.
    `MultiMap` | `trailers()` |

    - ### Methods inherited from interface io.vertx.core.http.HttpResponseHead

      `cookies, getHeader, getHeader, headers, statusCode, statusMessage, version`

    - ### Methods inherited from interface io.vertx.core.streams.ReadStream

      `collect, pipe, pipeTo`

- - ### Method Detail

    - #### fetch

          HttpClientResponse fetch​(long amount)

      Description copied from interface: `ReadStream`
      Fetch the specified `amount` of elements. If the `ReadStream` has been paused, reading will recommence with the specified `amount` of items, otherwise the specified `amount` will be added to the current stream demand.
      Specified by:
        `fetch` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### resume

          HttpClientResponse resume()

      Description copied from interface: `ReadStream`
      Resume reading, and sets the buffer in `flowing` mode.

      If the `ReadStream` has been paused, reading will recommence on it.
      Specified by:
        `resume` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          HttpClientResponse exceptionHandler​(Handler<Throwable> handler)

      Description copied from interface: `ReadStream`
      Set an exception handler on the read stream.
      Specified by:
        `exceptionHandler` in interface `ReadStream<Buffer>`
      Specified by:
        `exceptionHandler` in interface `StreamBase`
      Parameters:
        `handler` - the exception handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### handler

          HttpClientResponse handler​(Handler<Buffer> handler)

      Description copied from interface: `ReadStream`
      Set a data handler. As data is read, the handler will be called with the data.
      Specified by:
        `handler` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### pause

          HttpClientResponse pause()

      Description copied from interface: `ReadStream`
      Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.

      While it's paused, no data will be sent to the data `handler`.

      Specified by:
        `pause` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### endHandler

          HttpClientResponse endHandler​(Handler<Void> endHandler)

      Description copied from interface: `ReadStream`
      Set an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called.
      Specified by:
        `endHandler` in interface `ReadStream<Buffer>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### netSocket

          NetSocket netSocket()

      Returns:
        a `NetSocket` facade to interact with the HTTP client response.

    - #### getTrailer

          String getTrailer​(String trailerName)

      Return the first trailer value with the specified name
      Parameters:
        `trailerName` - the trailer name
      Returns:
        the trailer value

    - #### trailers

          MultiMap trailers()

      Returns:
        the trailers

    - #### bodyHandler

          default HttpClientResponse bodyHandler​(Handler<Buffer> bodyHandler)

      Convenience method for receiving the entire request body in one piece.

      This saves you having to manually set a dataHandler and an endHandler and append the chunks of the body until the whole body received. Don't use this if your request body is large - you could potentially run out of RAM.

      Parameters:
        `bodyHandler` - This handler will be called after all the body has been received

    - #### body

          Future<Buffer> body()

      Convenience method for receiving the entire request body in one piece.

      This saves you having to manually set a dataHandler and an endHandler and append the chunks of the body until the whole body received. Don't use this if your request body is large - you could potentially run out of RAM.

      Returns:
        a future completed with the body result

    - #### end

          Future<Void> end()

      Returns a future signaling when the response has been fully received successfully or failed.
      Returns:
        a future completed with the body result

    - #### customFrameHandler

          HttpClientResponse customFrameHandler​(Handler<HttpFrame> handler)

      Set an custom frame handler. The handler will get notified when the http stream receives an custom HTTP/2 frame. HTTP/2 permits extension of the protocol.
      Returns:
        a reference to this, so the API can be used fluently

    - #### request

          HttpClientRequest request()

      Returns:
        the corresponding request

    - #### streamPriorityHandler

          HttpClientResponse streamPriorityHandler​(Handler<StreamPriority> handler)

      Set an handler for stream priority changes.

      This is not implemented for HTTP/1.x.
      Parameters:
        `handler` - the handler to be called when the stream priority changes