diskfileitem.java

Wicket一个开发Java Web应用程序框架。它使得开发web应用程序变得容易而轻松。 Wicket利用一个POJO data beans组件使得它可以与任何持久层技术相结合。

	/**
	 * 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.
	 * 
	 * @exception 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)
			{
				/*
				 * 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));
						byte[] bytes = new byte[WRITE_BUFFER_SIZE];
						int s = 0;
						while ((s = in.read(bytes)) != -1)
						{
							out.write(bytes, 0, s);
						}
					}
					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.
	 * 
	 * @exception 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)
		{
			String systemTmp = null;
			try
			{
				systemTmp = System.getProperty("java.io.tmpdir");
			}
			catch (SecurityException e)
			{
				throw new WicketRuntimeException(
						"Reading property java.io.tmpdir is not allowed"
								+ " for the current security settings. The repository location needs to be"
								+ " set manually, or upgrade permissions to allow reading the tmpdir property.");
			}
			tempDir = new File(systemTmp);
		}

		String fileName = "upload_" + getUniqueId() + ".tmp";

		File f = new File(tempDir, fileName);
		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()
	{
		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 < 100000000)
		{
			id = ("00000000" + id).substring(id.length());
		}
		return id;
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString()
	{
		return "name=" + this.getName() + ", StoreLocation=" +
				String.valueOf(this.getStoreLocation()) + ", size=" + this.getSize() + "bytes, " +
				"isFormField=" + isFormField() + ", FieldName=" + this.getFieldName();
	}
}