diskfileitem.java

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

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.wicket.util.upload;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Map;

import org.apache.wicket.WicketRuntimeException;
import org.apache.wicket.util.file.FileCleaner;
import org.apache.wicket.util.io.DeferredFileOutputStream;


/**
 * <p>
 * The default implementation of the {@link org.apache.wicket.util.upload.FileItem FileItem}
 * interface.
 * 
 * <p>
 * After retrieving an instance of this class, you may either request all contents of file at once
 * using {@link #get()} or request an {@link java.io.InputStream InputStream} with
 * {@link #getInputStream()} and process the file without attempting to load it into memory, which
 * may come handy with large files.
 * 
 * @author <a href="mailto:[e-mail]">Rafal Krzewski</a>
 * @author <a href="mailto:[e-mail]">Sean Legassick</a>
 * @author <a href="mailto:[e-mail]">Jason van Zyl</a>
 * @author <a href="mailto:[e-mail]">John McNally</a>
 * @author <a href="mailto:[e-mail]">Martin Cooper</a>
 * @author Sean C. Sullivan
 */
public class DiskFileItem implements FileItem
{

	private static final long serialVersionUID = 1L;

	// ----------------------------------------------------- Manifest constants


	/**
	 * Default content charset to be used when no explicit charset parameter is provided by the
	 * sender. Media subtypes of the "text" type are defined to have a default charset value of
	 * "ISO-8859-1" when received via HTTP.
	 */
	public static final String DEFAULT_CHARSET = "ISO-8859-1";


	/**
	 * Size of buffer to use when writing an item to disk.
	 */
	private static final int WRITE_BUFFER_SIZE = 2048;


	// ----------------------------------------------------------- Data members


	/**
	 * Counter used in unique identifier generation.
	 */
	private static int counter = 0;


	/**
	 * The name of the form field as provided by the browser.
	 */
	private String fieldName;


	/**
	 * The content type passed by the browser, or <code>null</code> if not defined.
	 */
	private final String contentType;


	/**
	 * Whether or not this item is a simple form field.
	 */
	private boolean isFormField;


	/**
	 * The original filename in the user's filesystem.
	 */
	private final String fileName;


	/**
	 * The threshold above which uploads will be stored on disk.
	 */
	private final int sizeThreshold;


	/**
	 * The directory in which uploaded files will be stored, if stored on disk.
	 */
	private final File repository;


	/**
	 * Cached contents of the file.
	 */
	private byte[] cachedContent;


	/**
	 * Output stream for this item.
	 */
	private DeferredFileOutputStream dfos;


	// ----------------------------------------------------------- Constructors


	/**
	 * Constructs a new <code>DiskFileItem</code> instance.
	 * 
	 * @param fieldName
	 *            The name of the form field.
	 * @param contentType
	 *            The content type passed by the browser or <code>null</code> if not specified.
	 * @param isFormField
	 *            Whether or not this item is a plain form field, as opposed to a file upload.
	 * @param fileName
	 *            The original filename in the user's filesystem, or <code>null</code> if not
	 *            specified.
	 * @param sizeThreshold
	 *            The threshold, in bytes, below which items will be retained in memory and above
	 *            which they will be stored as a file.
	 * @param repository
	 *            The data repository, which is the directory in which files will be created, should
	 *            the item size exceed the threshold.
	 */
	public DiskFileItem(String fieldName, String contentType, boolean isFormField, String fileName,
			int sizeThreshold, File repository)
	{
		this.fieldName = fieldName;
		this.contentType = contentType;
		this.isFormField = isFormField;
		this.fileName = fileName;
		this.sizeThreshold = sizeThreshold;
		this.repository = repository;
	}


	// ------------------------------- Methods from javax.activation.DataSource


	/**
	 * Returns an {@link java.io.InputStream InputStream} that can be used to retrieve the contents
	 * of the file.
	 * 
	 * @return An {@link java.io.InputStream InputStream} that can be used to retrieve the contents
	 *         of the file.
	 * 
	 * @exception IOException
	 *                if an error occurs.
	 */
	public InputStream getInputStream() throws IOException
	{
		if (!dfos.isInMemory())
		{
			return new FileInputStream(dfos.getFile());
		}

		if (cachedContent == null)
		{
			cachedContent = dfos.getData();
		}
		return new ByteArrayInputStream(cachedContent);
	}


	/**
	 * Returns the content type passed by the agent or <code>null</code> if not defined.
	 * 
	 * @return The content type passed by the agent or <code>null</code> if not defined.
	 */
	public String getContentType()
	{
		return contentType;
	}


	/**
	 * Returns the content charset passed by the agent or <code>null</code> if not defined.
	 * 
	 * @return The content charset passed by the agent or <code>null</code> if not defined.
	 */
	public String getCharSet()
	{
		ParameterParser parser = new ParameterParser();
		parser.setLowerCaseNames(true);
		// Parameter parser can handle null input
		Map params = parser.parse(getContentType(), ';');
		return (String)params.get("charset");
	}


	/**
	 * Returns the original filename in the client's filesystem.
	 * 
	 * @return The original filename in the client's filesystem.
	 */
	public String getName()
	{
		return fileName;
	}


	// ------------------------------------------------------- FileItem methods


	/**
	 * Provides a hint as to whether or not the file contents will be read from memory.
	 * 
	 * @return <code>true</code> if the file contents will be read from memory; <code>false</code>
	 *         otherwise.
	 */
	public boolean isInMemory()
	{
		return (dfos.isInMemory());
	}


	/**
	 * Returns the size of the file.
	 * 
	 * @return The size of the file, in bytes.
	 */
	public long getSize()
	{
		if (cachedContent != null)
		{
			return cachedContent.length;
		}
		else if (dfos.isInMemory())
		{
			return dfos.getData().length;
		}
		else
		{
			return dfos.getFile().length();
		}
	}


	/**
	 * Returns the contents of the file as an array of bytes. If the contents of the file were not
	 * yet cached in memory, they will be loaded from the disk storage and cached.
	 * 
	 * @return The contents of the file as an array of bytes.
	 */
	public byte[] get()
	{
		if (dfos.isInMemory())
		{
			if (cachedContent == null)
			{
				cachedContent = dfos.getData();
			}
			return cachedContent;
		}

		byte[] fileData = new byte[(int)getSize()];
		FileInputStream fis = null;

		try
		{
			fis = new FileInputStream(dfos.getFile());
			fis.read(fileData);
		}
		catch (IOException e)
		{
			fileData = null;
		}
		finally
		{
			if (fis != null)
			{
				try
				{
					fis.close();
				}
				catch (IOException e)
				{
					// ignore
				}
			}
		}

		return fileData;
	}


	/**
	 * Returns the contents of the file as a String, using the specified encoding. This method uses
	 * {@link #get()} to retrieve the contents of the file.
	 * 
	 * @param charset
	 *            The charset to use.
	 * 
	 * @return The contents of the file, as a string.
	 * 
	 * @exception UnsupportedEncodingException
	 *                if the requested character encoding is not available.
	 */
	public String getString(final String charset) throws UnsupportedEncodingException
	{
		return new String(get(), charset);
	}