org.apache.myfaces.trinidad.webapp

## Interface UploadedFileProcessor

- All Known Subinterfaces:
    ChainedUploadedFileProcessor

      public interface UploadedFileProcessor

  Interface responsible for processing file uploads. An Apache Trinidad application has a single `UploadedFileProcessor` instance. For more simpler, multiple chained UploadedFileProcessor option please look at `ChainedUploadedFileProcessor`. UploadedFileProcessor is accessible from the `RequestContext`, but will be invoked automatically by the framework as needed. Developers can replace the standard processor using the `trinidad-config.xml` file.

  To configure file uploads, the default instance supports three context initialization parameters :

  - org.apache.myfaces.trinidad.UPLOAD_MAX_MEMORY: the maximum amount of memory that can be used in a single request to store uploaded files. (Default of 100K)
  - org.apache.myfaces.trinidad.UPLOAD_MAX_DISK_SPACE: the maximum amount of disk space that can be used in a single request to store uploaded files. (Default of 2000K)
  - org.apache.myfaces.trinidad.UPLOAD_TEMP_DIR: the name of a directory to store temporary files. (Defaults to the user's temporary directory)
  See Also:
    `UploadedFile`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static String` | `MAX_DISK_SPACE_PARAM_NAME` Initialization parameter for the default `UploadedFileProcessor` that configures the maximum amount of disk space that can be used in a single request to store uploaded files.
    `static String` | `MAX_MEMORY_PARAM_NAME` Initialization parameter for the default `UploadedFileProcessor` that configures the maximum amount of memory that can be used in a single request to store uploaded files.
    `static String` | `TEMP_DIR_PARAM_NAME` Initialization parameter for the default `UploadedFileProcessor` that configures the to the directory where temporary files should be stored while uploading.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `init(Object context)` Initialize the UploadedFileProcessor with access to the current web application context.
    `UploadedFile` | `processFile(Object request, UploadedFile file)` Process a single uploaded file, moving it from temporary storage to per-request storage.

- - ### Field Detail

    - #### MAX_MEMORY_PARAM_NAME

          static final String MAX_MEMORY_PARAM_NAME

      Initialization parameter for the default `UploadedFileProcessor` that configures the maximum amount of memory that can be used in a single request to store uploaded files. Any requirements above this will be stored on disk. The default is 100 kilobytes.
      See Also:
        Constant Field Values

    - #### MAX_DISK_SPACE_PARAM_NAME

          static final String MAX_DISK_SPACE_PARAM_NAME

      Initialization parameter for the default `UploadedFileProcessor` that configures the maximum amount of disk space that can be used in a single request to store uploaded files. The default is 2000 kilobytes. Any requests that exceed this size will result in an EOFException being thrown on that request.
      See Also:
        Constant Field Values

    - #### TEMP_DIR_PARAM_NAME

          static final String TEMP_DIR_PARAM_NAME

      Initialization parameter for the default `UploadedFileProcessor` that configures the to the directory where temporary files should be stored while uploading. This defaults to the the application server's temporary directory, as provided by the "javax.servlet.context.tempdir" property. If that is not set, the System "java.io.tempdir" property will be used as a backup.
      See Also:
        Constant Field Values

  - ### Method Detail

    - #### init

          void init(Object context)

      Initialize the UploadedFileProcessor with access to the current web application context.
      Parameters:
        `context` - the current ServletContext or PortletContext

    - #### processFile

          UploadedFile processFile(Object request,
                                 UploadedFile file)
                                   throws IOException

      Process a single uploaded file, moving it from temporary storage to per-request storage. An implementation of this method must process an incoming `UploadedFile` object and return a new `UploadedFile` instance that will remain valid for the duration of this request. The incoming `UploadedFile` object is a temporary file object that has a number of restrictions:
      - `UploadedFile.getInputStream()` may only be called once
      - `UploadedFile.getLength()` returns -1, since the length is not yet available
      - `UploadedFile.getFilename()` has not yet been internationalized; users should not rely on its value, but simply use it unmodified in the outgoing `UploadedFile`

      The `UploadedFile` object returned from this method must remain valid for the duration of this request. The framework guarantees that `UploadedFile.dispose()` will be called before the request completes.

      Parameters:
        `request` - the current servlet or portlet request
        `file` - a temporary file object
      Returns:
        a new instance of UploadedFile. It is legal to return null, in which case the file will not be available later in the request.
      Throws:
        `IOException`

Copyright © 2001-2016 The Apache Software Foundation. All Rights Reserved.