org.jboss.resteasy.plugins.providers.multipart

## Class MultipartReader

- java.lang.Object
- - org.jboss.resteasy.plugins.providers.multipart.MultipartReader

- All Implemented Interfaces:
    MessageBodyReader<MultipartInput>

      @Provider
      @Consumes(value="multipart/*")
      public class MultipartReader
      extends Object
      implements MessageBodyReader<MultipartInput>

  Version:
    $Revision: 1 $
  Author:
    Bill Burke

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Providers` | `workers`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MultipartReader()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType)` Ascertain if the MessageBodyReader can produce an instance of a particular type.
    `MultipartInput` | `readFrom(Class<MultipartInput> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String,String> httpHeaders, InputStream entityStream)` Read a type from the `InputStream`.

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

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

- - ### Field Detail

    - #### workers

          @Context
          protected Providers workers

  - ### Constructor Detail

    - #### MultipartReader

          public MultipartReader()

  - ### Method Detail

    - #### isReadable

          public boolean isReadable(Class<?> type,
                           Type genericType,
                           Annotation[] annotations,
                           MediaType mediaType)

      Description copied from interface: `MessageBodyReader`
      Ascertain if the MessageBodyReader can produce an instance of a particular type. The `type` parameter gives the class of the instance that should be produced, the `genericType` parameter gives the `java.lang.reflect.Type` of the instance that should be produced. E.g. if the instance to be produced is `List<String>`, the `type` parameter will be `java.util.List` and the `genericType` parameter will be `java.lang.reflect.ParameterizedType`.
      Specified by:
        `isReadable` in interface `MessageBodyReader<MultipartInput>`
      Parameters:
        `type` - the class of instance to be produced.
        `genericType` - the type of instance to be produced. E.g. if the message body is to be converted into a method parameter, this will be the formal type of the method parameter as returned by `Method.getGenericParameterTypes`.
        `annotations` - an array of the annotations on the declaration of the artifact that will be initialized with the produced instance. E.g. if the message body is to be converted into a method parameter, this will be the annotations on that parameter returned by `Method.getParameterAnnotations`.
        `mediaType` - the media type of the HTTP entity, if one is not specified in the request then `application/octet-stream` is used.
      Returns:
        `true` if the type is supported, otherwise `false`.

    - #### readFrom

          public MultipartInput readFrom(Class<MultipartInput> type,
                                Type genericType,
                                Annotation[] annotations,
                                MediaType mediaType,
                                MultivaluedMap<String,String> httpHeaders,
                                InputStream entityStream)
                                  throws IOException,
                                         WebApplicationException

      Description copied from interface: `MessageBodyReader`
      Read a type from the `InputStream`.

      In case the entity input stream is empty, the reader is expected to either return a Java representation of a zero-length entity or throw a `NoContentException` in case no zero-length entity representation is defined for the supported Java type. A `NoContentException`, if thrown by a message body reader while reading a server request entity, is automatically translated by JAX-RS server runtime into a `BadRequestException` wrapping the original `NoContentException` and rethrown for a standard processing by the registered `exception mappers`.

      Specified by:
        `readFrom` in interface `MessageBodyReader<MultipartInput>`
      Parameters:
        `type` - the type that is to be read from the entity stream.
        `genericType` - the type of instance to be produced. E.g. if the message body is to be converted into a method parameter, this will be the formal type of the method parameter as returned by `Method.getGenericParameterTypes`.
        `annotations` - an array of the annotations on the declaration of the artifact that will be initialized with the produced instance. E.g. if the message body is to be converted into a method parameter, this will be the annotations on that parameter returned by `Method.getParameterAnnotations`.
        `mediaType` - the media type of the HTTP entity.
        `httpHeaders` - the read-only HTTP headers associated with HTTP entity.
        `entityStream` - the `InputStream` of the HTTP entity. The caller is responsible for ensuring that the input stream ends when the entity has been consumed. The implementation should not close the input stream.
      Returns:
        the type that was read from the stream. In case the entity input stream is empty, the reader is expected to either return an instance representing a zero-length entity or throw a `NoContentException` in case no zero-length entity representation is defined for the supported Java type.
      Throws:
        `IOException` - if an IO error arises. In case the entity input stream is empty and the reader is not able to produce a Java representation for a zero-length entity, `NoContentException` is expected to be thrown.
        `WebApplicationException` - if a specific HTTP error response needs to be produced. Only effective if thrown prior to the response being committed.

Copyright © 2014. All Rights Reserved.