/**     * Returns the contents of the file as a String, using the default     * character encoding.  This method uses {@link #get()} to retrieve the     * contents of the file.     *     * @return The contents of the file, as a string.     *     * @todo Consider making this method throw UnsupportedEncodingException.     */    public String getString() {        byte[] rawdata = get();        String charset = getCharSet();        if (charset == null) {            charset = DEFAULT_CHARSET;        }        try {            return new String(rawdata, charset);        } catch (UnsupportedEncodingException e) {            return new String(rawdata);        }    }    /**     * A convenience method to write an uploaded item to disk. The client code     * is not concerned with whether or not the item is stored in memory, or on     * disk in a temporary location. They just want to write the uploaded item     * to a file.     * <p>     * This implementation first attempts to rename the uploaded item to the     * specified destination file, if the item was originally written to disk.     * Otherwise, the data will be copied to the specified file.     * <p>     * This method is only guaranteed to work <em>once</em>, the first time it     * is invoked for a particular item. This is because, in the event that the     * method renames a temporary file, that file will no longer be available     * to copy or rename again at a later time.     *     * @param file The <code>File</code> into which the uploaded item should     *             be stored.     *     * @throws Exception if an error occurs.     */    public void write(File file) throws Exception {        if (isInMemory()) {            FileOutputStream fout = null;            try {                fout = new FileOutputStream(file);                fout.write(get());            } finally {                if (fout != null) {                    fout.close();                }            }        } else {            File outputFile = getStoreLocation();            if (outputFile != null) {                // Save the length of the file                size = outputFile.length();                /*                 * The uploaded file is being stored on disk                 * in a temporary location so move it to the                 * desired file.                 */                if (!outputFile.renameTo(file)) {                    BufferedInputStream in = null;                    BufferedOutputStream out = null;                    try {                        in = new BufferedInputStream(                            new FileInputStream(outputFile));                        out = new BufferedOutputStream(                                new FileOutputStream(file));                        IOUtils.copy(in, out);                    } finally {                        if (in != null) {                            try {                                in.close();                            } catch (IOException e) {                                // ignore                            }                        }                        if (out != null) {                            try {                                out.close();                            } catch (IOException e) {                                // ignore                            }                        }                    }                }            } else {                /*                 * For whatever reason we cannot write the                 * file to disk.                 */                throw new FileUploadException(                    "Cannot write uploaded file to disk!");            }        }    }    /**     * Deletes the underlying storage for a file item, including deleting any     * associated temporary disk file. Although this storage will be deleted     * automatically when the <code>FileItem</code> instance is garbage     * collected, this method can be used to ensure that this is done at an     * earlier time, thus preserving system resources.     */    public void delete() {        cachedContent = null;        File outputFile = getStoreLocation();        if (outputFile != null && outputFile.exists()) {            outputFile.delete();        }    }    /**     * Returns the name of the field in the multipart form corresponding to     * this file item.     *     * @return The name of the form field.     *     * @see #setFieldName(java.lang.String)     *     */    public String getFieldName() {        return fieldName;    }    /**     * Sets the field name used to reference this file item.     *     * @param fieldName The name of the form field.     *     * @see #getFieldName()     *     */    public void setFieldName(String fieldName) {        this.fieldName = fieldName;    }    /**     * Determines whether or not a <code>FileItem</code> instance represents     * a simple form field.     *     * @return <code>true</code> if the instance represents a simple form     *         field; <code>false</code> if it represents an uploaded file.     *     * @see #setFormField(boolean)     *     */    public boolean isFormField() {        return isFormField;    }    /**     * Specifies whether or not a <code>FileItem</code> instance represents     * a simple form field.     *     * @param state <code>true</code> if the instance represents a simple form     *              field; <code>false</code> if it represents an uploaded file.     *     * @see #isFormField()     *     */    public void setFormField(boolean state) {        isFormField = state;    }    /**     * Returns an {@link java.io.OutputStream OutputStream} that can     * be used for storing the contents of the file.     *     * @return An {@link java.io.OutputStream OutputStream} that can be used     *         for storing the contensts of the file.     *     * @throws IOException if an error occurs.     */    public OutputStream getOutputStream()        throws IOException {        if (dfos == null) {            File outputFile = getTempFile();            dfos = new DeferredFileOutputStream(sizeThreshold, outputFile);        }        return dfos;    }    // --------------------------------------------------------- Public methods    /**     * Returns the {@link java.io.File} object for the <code>FileItem</code>'s     * data's temporary location on the disk. Note that for     * <code>FileItem</code>s that have their data stored in memory,     * this method will return <code>null</code>. When handling large     * files, you can use {@link java.io.File#renameTo(java.io.File)} to     * move the file to new location without copying the data, if the     * source and destination locations reside within the same logical     * volume.     *     * @return The data file, or <code>null</code> if the data is stored in     *         memory.     */    public File getStoreLocation() {        return dfos.getFile();    }    // ------------------------------------------------------ Protected methods    /**     * Removes the file contents from the temporary storage.     */    protected void finalize() {        File outputFile = dfos.getFile();        if (outputFile != null && outputFile.exists()) {            outputFile.delete();        }    }    /**     * Creates and returns a {@link java.io.File File} representing a uniquely     * named temporary file in the configured repository path. The lifetime of     * the file is tied to the lifetime of the <code>FileItem</code> instance;     * the file will be deleted when the instance is garbage collected.     *     * @return The {@link java.io.File File} to be used for temporary storage.     */    protected File getTempFile() {        File tempDir = repository;        if (tempDir == null) {            tempDir = new File(System.getProperty("java.io.tmpdir"));        }        String tempFileName = "upload_" + UID + "_" + getUniqueId() + ".tmp";        File f = new File(tempDir, tempFileName);        FileCleaner.track(f, this);        return f;    }    // -------------------------------------------------------- Private methods    /**     * Returns an identifier that is unique within the class loader used to     * load this class, but does not have random-like apearance.     *     * @return A String with the non-random looking instance identifier.     */    private static String getUniqueId() {        final int limit = 100000000;        int current;        synchronized (DiskFileItem.class) {            current = counter++;        }        String id = Integer.toString(current);        // If you manage to get more than 100 million of ids, you'll        // start getting ids longer than 8 characters.        if (current < limit) {            id = ("00000000" + id).substring(id.length());        }        return id;    }    /**     * Returns a string representation of this object.     *     * @return a string representation of this object.     */    public String toString() {        return "name=" + this.getName()            + ", StoreLocation="            + String.valueOf(this.getStoreLocation())            + ", size="            + this.getSize()            + "bytes, "            + "isFormField=" + isFormField()            + ", FieldName="            + this.getFieldName();    }    // -------------------------------------------------- Serialization methods    /**     * Writes the state of this object during serialization.     *     * @param out The stream to which the state should be written.     *     * @throws IOException if an error occurs.     */    private void writeObject(ObjectOutputStream out) throws IOException {        // Read the data        if (dfos.isInMemory()) {            cachedContent = get();        } else {            cachedContent = null;            dfosFile = dfos.getFile();        }        // write out values        out.defaultWriteObject();    }    /**     * Reads the state of this object during deserialization.     *     * @param in The stream from which the state should be read.     *     * @throws IOException if an error occurs.     * @throws ClassNotFoundException if class cannot be found.     */    private void readObject(ObjectInputStream in)            throws IOException, ClassNotFoundException {        // read values        in.defaultReadObject();        OutputStream output = getOutputStream();        if (cachedContent != null) {            output.write(cachedContent);        } else {            FileInputStream input = new FileInputStream(dfosFile);            IOUtils.copy(input, output);            dfosFile.delete();            dfosFile = null;        }        output.close();        cachedContent = null;    }}