org.jboss.resteasy.specimpl

## Class BuiltResponse

- java.lang.Object
- - javax.ws.rs.core.Response
  - - org.jboss.resteasy.specimpl.BuiltResponse

- Direct Known Subclasses:
    ClientResponse, ServerResponse

      public class BuiltResponse
      extends Response

  A response object not attached to a client or server invocation.
  Version:
    $Revision: 1 $
  Author:
    Bill Burke

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class javax.ws.rs.core.Response

      `Response.ResponseBuilder, Response.Status, Response.StatusType`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Annotation[]` | `annotations`
    `protected Object` | `entity`
    `protected Class` | `entityClass`
    `protected Type` | `genericType`
    `protected boolean` | `isClosed`
    `protected Headers<Object>` | `metadata`
    `protected HeaderValueProcessor` | `processor`
    `protected int` | `status`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BuiltResponse()`
    `BuiltResponse(int status, Headers<Object> metadata, Object entity, Annotation[] entityAnnotations)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `abortIfClosed()`
    `void` | `addMethodAnnotations(Annotation[] methodAnnotations)`
    `boolean` | `bufferEntity()` Buffer the message entity data.
    `void` | `close()` Close the underlying message entity input stream (if available and open) as well as releases any other resources associated with the response (e.g.
    `Set<String>` | `getAllowedMethods()` Get the allowed HTTP methods from the Allow HTTP header.
    `Annotation[]` | `getAnnotations()`
    `Map<String,NewCookie>` | `getCookies()` Get any new cookies set on the response message.
    `Date` | `getDate()` Get message date.
    `Object` | `getEntity()` Get the message entity Java instance.
    `Class` | `getEntityClass()`
    `EntityTag` | `getEntityTag()` Get the entity tag.
    `Type` | `getGenericType()`
    `String` | `getHeaderString(String name)` Get a message header as a single string value.
    `protected HeaderValueProcessor` | `getHeaderValueProcessor()`
    `Locale` | `getLanguage()` Get the language of the message entity.
    `Date` | `getLastModified()` Get the last modified date.
    `int` | `getLength()` Get Content-Length value.
    `Link` | `getLink(String relation)` Get the link for the relation.
    `Link.Builder` | `getLinkBuilder(String relation)` Convenience method that returns a `Link.Builder` for the relation.
    `protected LinkHeaders` | `getLinkHeaders()`
    `Set<Link>` | `getLinks()` Get the links attached to the message as headers.
    `URI` | `getLocation()` Get the location.
    `MediaType` | `getMediaType()` Get the media type of the message entity.
    `MultivaluedMap<String,Object>` | `getMetadata()` See `Response.getHeaders()`.
    `int` | `getStatus()` Get the status code associated with the response.
    `Response.StatusType` | `getStatusInfo()` Get the complete status information associated with the response.
    `MultivaluedMap<String,String>` | `getStringHeaders()` Get view of the response headers and their string values.
    `boolean` | `hasEntity()` Check if there is an entity available in the response.
    `boolean` | `hasLink(String relation)` Check if link for relation exists.
    `boolean` | `isClosed()`
    `<T> T` | `readEntity(Class<T> type)` Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.
    `<T> T` | `readEntity(Class<T> type, Annotation[] annotations)` Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.
    `<T> T` | `readEntity(Class<T> type, Type genericType, Annotation[] anns)`
    `<T> T` | `readEntity(GenericType<T> entityType)` Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.
    `<T> T` | `readEntity(GenericType<T> entityType, Annotation[] annotations)` Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.
    `void` | `setAnnotations(Annotation[] annotations)`
    `void` | `setEntity(Object entity)`
    `void` | `setEntityClass(Class entityClass)`
    `void` | `setGenericType(Type genericType)`
    `void` | `setMetadata(MultivaluedMap<String,Object> metadata)`
    `void` | `setStatus(int status)`
    `protected String` | `toHeaderString(Object header)`

    - ### Methods inherited from class javax.ws.rs.core.Response

      `accepted, accepted, created, fromResponse, getHeaders, noContent, notAcceptable, notModified, notModified, notModified, ok, ok, ok, ok, ok, seeOther, serverError, status, status, status, temporaryRedirect`

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

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

- - ### Field Detail

    - #### entity

          protected Object entity

    - #### status

          protected int status

    - #### metadata

          protected Headers<Object> metadata

    - #### annotations

          protected Annotation[] annotations

    - #### entityClass

          protected Class entityClass

    - #### genericType

          protected Type genericType

    - #### processor

          protected HeaderValueProcessor processor

    - #### isClosed

          protected boolean isClosed

  - ### Constructor Detail

    - #### BuiltResponse

          public BuiltResponse()

    - #### BuiltResponse

          public BuiltResponse(int status,
                       Headers<Object> metadata,
                       Object entity,
                       Annotation[] entityAnnotations)

  - ### Method Detail

    - #### getEntityClass

          public Class getEntityClass()

    - #### setEntityClass

          public void setEntityClass(Class entityClass)

    - #### getHeaderValueProcessor

          protected HeaderValueProcessor getHeaderValueProcessor()

    - #### getEntity

          public Object getEntity()

      Description copied from class: `Response`
      Get the message entity Java instance. Returns `null` if the message does not contain an entity body.

      If the entity is represented by an un-consumed `input stream` the method will return the input stream.

      Specified by:
        `getEntity` in class `Response`
      Returns:
        the message entity or `null` if message does not contain an entity body (i.e. when `Response.hasEntity()` returns `false`).

    - #### getStatus

          public int getStatus()

      Description copied from class: `Response`
      Get the status code associated with the response.
      Specified by:
        `getStatus` in class `Response`
      Returns:
        the response status code.

    - #### getStatusInfo

          public Response.StatusType getStatusInfo()

      Description copied from class: `Response`
      Get the complete status information associated with the response.
      Specified by:
        `getStatusInfo` in class `Response`
      Returns:
        the response status information. The returned value is never `null`.

    - #### getMetadata

          public MultivaluedMap<String,Object> getMetadata()

      Description copied from class: `Response`
      See `Response.getHeaders()`. This method is considered deprecated. Users are encouraged to switch their code to use the `getHeaders()` method instead. The method may be annotated as `@Deprecated` in a future release of JAX-RS API.
      Specified by:
        `getMetadata` in class `Response`
      Returns:
        response headers as a multivalued map.

    - #### setEntity

          public void setEntity(Object entity)

    - #### setStatus

          public void setStatus(int status)

    - #### setMetadata

          public void setMetadata(MultivaluedMap<String,Object> metadata)

    - #### getAnnotations

          public Annotation[] getAnnotations()

    - #### addMethodAnnotations

          public void addMethodAnnotations(Annotation[] methodAnnotations)

    - #### setAnnotations

          public void setAnnotations(Annotation[] annotations)

    - #### getGenericType

          public Type getGenericType()

    - #### setGenericType

          public void setGenericType(Type genericType)

    - #### readEntity

          public <T> T readEntity(Class<T> type,
                         Annotation[] annotations)

      Description copied from class: `Response`
      Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.

      Method throws an `ProcessingException` if the content of the message cannot be mapped to an entity of the requested type and `IllegalStateException` in case the entity is not backed by an input stream or if the original entity input stream has already been consumed without `buffering` the entity data prior consuming.

      A message instance returned from this method will be cached for subsequent retrievals via `Response.getEntity()`. Unless the supplied entity type is an `input stream`, this method automatically `closes` the an unconsumed original response entity data stream if open. In case the entity data has been buffered, the buffer will be reset prior consuming the buffered data to enable subsequent invocations of `readEntity(...)` methods on this response.

      Specified by:
        `readEntity` in class `Response`
      Type Parameters:
        `T` - entity instance Java type.
      Parameters:
        `type` - the type of entity.
        `annotations` - annotations that will be passed to the `MessageBodyReader`.
      Returns:
        the message entity; for a zero-length response entities returns a corresponding Java object that represents zero-length data. In case no zero-length representation is defined for the Java type, a `ProcessingException` wrapping the underlying `NoContentException` is thrown.
      See Also:
        `MessageBodyReader`

    - #### readEntity

          public <T> T readEntity(GenericType<T> entityType,
                         Annotation[] annotations)

      Description copied from class: `Response`
      Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.

      Method throws an `ProcessingException` if the content of the message cannot be mapped to an entity of the requested type and `IllegalStateException` in case the entity is not backed by an input stream or if the original entity input stream has already been consumed without `buffering` the entity data prior consuming.

      A message instance returned from this method will be cached for subsequent retrievals via `Response.getEntity()`. Unless the supplied entity type is an `input stream`, this method automatically `closes` the an unconsumed original response entity data stream if open. In case the entity data has been buffered, the buffer will be reset prior consuming the buffered data to enable subsequent invocations of `readEntity(...)` methods on this response.

      Specified by:
        `readEntity` in class `Response`
      Type Parameters:
        `T` - entity instance Java type.
      Parameters:
        `entityType` - the type of entity; may be generic.
        `annotations` - annotations that will be passed to the `MessageBodyReader`.
      Returns:
        the message entity; for a zero-length response entities returns a corresponding Java object that represents zero-length data. In case no zero-length representation is defined for the Java type, a `ProcessingException` wrapping the underlying `NoContentException` is thrown.
      See Also:
        `MessageBodyReader`

    - #### readEntity

          public <T> T readEntity(Class<T> type)

      Description copied from class: `Response`
      Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.

      Method throws an `ProcessingException` if the content of the message cannot be mapped to an entity of the requested type and `IllegalStateException` in case the entity is not backed by an input stream or if the original entity input stream has already been consumed without `buffering` the entity data prior consuming.

      A message instance returned from this method will be cached for subsequent retrievals via `Response.getEntity()`. Unless the supplied entity type is an `input stream`, this method automatically `closes` the an unconsumed original response entity data stream if open. In case the entity data has been buffered, the buffer will be reset prior consuming the buffered data to enable subsequent invocations of `readEntity(...)` methods on this response.

      Specified by:
        `readEntity` in class `Response`
      Type Parameters:
        `T` - entity instance Java type.
      Parameters:
        `type` - the type of entity.
      Returns:
        the message entity; for a zero-length response entities returns a corresponding Java object that represents zero-length data. In case no zero-length representation is defined for the Java type, a `ProcessingException` wrapping the underlying `NoContentException` is thrown.
      See Also:
        `MessageBodyReader`

    - #### readEntity

          public <T> T readEntity(GenericType<T> entityType)

      Description copied from class: `Response`
      Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.

      Method throws an `ProcessingException` if the content of the message cannot be mapped to an entity of the requested type and `IllegalStateException` in case the entity is not backed by an input stream or if the original entity input stream has already been consumed without `buffering` the entity data prior consuming.

      A message instance returned from this method will be cached for subsequent retrievals via `Response.getEntity()`. Unless the supplied entity type is an `input stream`, this method automatically `closes` the an unconsumed original response entity data stream if open. In case the entity data has been buffered, the buffer will be reset prior consuming the buffered data to enable subsequent invocations of `readEntity(...)` methods on this response.

      Specified by:
        `readEntity` in class `Response`
      Type Parameters:
        `T` - entity instance Java type.
      Parameters:
        `entityType` - the type of entity; may be generic.
      Returns:
        the message entity; for a zero-length response entities returns a corresponding Java object that represents zero-length data. In case no zero-length representation is defined for the Java type, a `ProcessingException` wrapping the underlying `NoContentException` is thrown.
      See Also:
        `MessageBodyReader`

    - #### readEntity

          public <T> T readEntity(Class<T> type,
                         Type genericType,
                         Annotation[] anns)

    - #### hasEntity

          public boolean hasEntity()

      Description copied from class: `Response`
      Check if there is an entity available in the response. The method returns `true` if the entity is present, returns `false` otherwise.

      Note that the method may return `true` also for response messages with a zero-length content, in case the `"Content-Length"` and `"Content-Type"` headers are specified in the message. In such case, an attempt to read the entity using one of the `readEntity(...)` methods will return a corresponding instance representing a zero-length entity for a given Java type or produce a `ProcessingException` in case no such instance is available for the Java type.

      Specified by:
        `hasEntity` in class `Response`
      Returns:
        `true` if there is an entity present in the message, `false` otherwise.

    - #### bufferEntity

          public boolean bufferEntity()

      Description copied from class: `Response`
      Buffer the message entity data.

      In case the message entity is backed by an unconsumed entity input stream, all the bytes of the original entity input stream are read and stored in a local buffer. The original entity input stream is consumed and automatically closed as part of the operation and the method returns `true`.

      In case the response entity instance is not backed by an unconsumed input stream an invocation of `bufferEntity` method is ignored and the method returns `false`.

      This operation is idempotent, i.e. it can be invoked multiple times with the same effect which also means that calling the `bufferEntity()` method on an already buffered (and thus closed) message instance is legal and has no further effect. Also, the result returned by the `bufferEntity()` method is consistent across all invocations of the method on the same `Response` instance.

      Buffering the message entity data allows for multiple invocations of `readEntity(...)` methods on the response instance. Note however, that once the response instance itself is `closed`, the implementations are expected to release the buffered message entity data too. Therefore any subsequent attempts to read a message entity stream on such closed response will result in an `IllegalStateException` being thrown.

      Specified by:
        `bufferEntity` in class `Response`
      Returns:
        `true` if the message entity input stream was available and was buffered successfully, returns `false` if the entity stream was not available.

    - #### isClosed

          public boolean isClosed()

    - #### abortIfClosed

          public void abortIfClosed()

    - #### close

          public void close()

      Description copied from class: `Response`
      Close the underlying message entity input stream (if available and open) as well as releases any other resources associated with the response (e.g. `buffered message entity data`).

      This operation is idempotent, i.e. it can be invoked multiple times with the same effect which also means that calling the `close()` method on an already closed message instance is legal and has no further effect.

      The `close()` method should be invoked on all instances that contain an un-consumed entity input stream to ensure the resources associated with the instance are properly cleaned-up and prevent potential memory leaks. This is typical for client-side scenarios where application layer code processes only the response headers and ignores the response entity.

      Any attempts to manipulate (read, get, buffer) a message entity on a closed response will result in an `IllegalStateException` being thrown.

      Specified by:
        `close` in class `Response`

    - #### getLanguage

          public Locale getLanguage()

      Description copied from class: `Response`
      Get the language of the message entity.
      Specified by:
        `getLanguage` in class `Response`
      Returns:
        the language of the entity or null if not specified.

    - #### getLength

          public int getLength()

      Description copied from class: `Response`
      Get Content-Length value.
      Specified by:
        `getLength` in class `Response`
      Returns:
        Content-Length as integer if present and valid number. In other cases returns `-1`.

    - #### getMediaType

          public MediaType getMediaType()

      Description copied from class: `Response`
      Get the media type of the message entity.
      Specified by:
        `getMediaType` in class `Response`
      Returns:
        the media type or `null` if there is no response entity.

    - #### getCookies

          public Map<String,NewCookie> getCookies()

      Description copied from class: `Response`
      Get any new cookies set on the response message.
      Specified by:
        `getCookies` in class `Response`
      Returns:
        a read-only map of cookie name (String) to Cookie.

    - #### getEntityTag

          public EntityTag getEntityTag()

      Description copied from class: `Response`
      Get the entity tag.
      Specified by:
        `getEntityTag` in class `Response`
      Returns:
        the entity tag, otherwise `null` if not present.

    - #### getDate

          public Date getDate()

      Description copied from class: `Response`
      Get message date.
      Specified by:
        `getDate` in class `Response`
      Returns:
        the message date, otherwise `null` if not present.

    - #### getLastModified

          public Date getLastModified()

      Description copied from class: `Response`
      Get the last modified date.
      Specified by:
        `getLastModified` in class `Response`
      Returns:
        the last modified date, otherwise `null` if not present.

    - #### getAllowedMethods

          public Set<String> getAllowedMethods()

      Description copied from class: `Response`
      Get the allowed HTTP methods from the Allow HTTP header.
      Specified by:
        `getAllowedMethods` in class `Response`
      Returns:
        the allowed HTTP methods, all methods will returned as upper case strings.

    - #### toHeaderString

          protected String toHeaderString(Object header)

    - #### getStringHeaders

          public MultivaluedMap<String,String> getStringHeaders()

      Description copied from class: `Response`
      Get view of the response headers and their string values. The underlying header data may be subsequently modified by the JAX-RS runtime on the server side. Changes in the underlying header data are reflected in this view.
      Specified by:
        `getStringHeaders` in class `Response`
      Returns:
        response headers as a string view of header values.
      See Also:
        `Response.getHeaders()`, `Response.getHeaderString(java.lang.String)`

    - #### getHeaderString

          public String getHeaderString(String name)

      Description copied from class: `Response`
      Get a message header as a single string value. Each single header value is converted to String using a `RuntimeDelegate.HeaderDelegate` if one is available via `RuntimeDelegate.createHeaderDelegate(java.lang.Class)` for the header value class or using its `toString` method if a header delegate is not available.
      Specified by:
        `getHeaderString` in class `Response`
      Parameters:
        `name` - the message header.
      Returns:
        the message header value. If the message header is not present then `null` is returned. If the message header is present but has no value then the empty string is returned. If the message header is present more than once then the values of joined together and separated by a ',' character.
      See Also:
        `Response.getHeaders()`, `Response.getStringHeaders()`

    - #### getLocation

          public URI getLocation()

      Description copied from class: `Response`
      Get the location.
      Specified by:
        `getLocation` in class `Response`
      Returns:
        the location URI, otherwise `null` if not present.

    - #### getLinks

          public Set<Link> getLinks()

      Description copied from class: `Response`
      Get the links attached to the message as headers. Any links in the message that are relative must be resolved with respect to the actual request URI that produced this response. Note that request URIs may be updated by filters, so the actual request URI may differ from that in the original invocation.
      Specified by:
        `getLinks` in class `Response`
      Returns:
        links, may return empty `Set` if no links are present. Does not return `null`.

    - #### getLinkHeaders

          protected LinkHeaders getLinkHeaders()

    - #### hasLink

          public boolean hasLink(String relation)

      Description copied from class: `Response`
      Check if link for relation exists.
      Specified by:
        `hasLink` in class `Response`
      Parameters:
        `relation` - link relation.
      Returns:
        `true` if the link for the relation is present in the `message headers`, `false` otherwise.

    - #### getLink

          public Link getLink(String relation)

      Description copied from class: `Response`
      Get the link for the relation. A relative link is resolved with respect to the actual request URI that produced this response. Note that request URIs may be updated by filters, so the actual request URI may differ from that in the original invocation.
      Specified by:
        `getLink` in class `Response`
      Parameters:
        `relation` - link relation.
      Returns:
        the link for the relation, otherwise `null` if not present.

    - #### getLinkBuilder

          public Link.Builder getLinkBuilder(String relation)

      Description copied from class: `Response`
      Convenience method that returns a `Link.Builder` for the relation. See `Response.getLink(java.lang.String)` for more information.
      Specified by:
        `getLinkBuilder` in class `Response`
      Parameters:
        `relation` - link relation.
      Returns:
        the link builder for the relation, otherwise `null` if not present.

Copyright © 2014. All Rights Reserved.