基于apache commons.fileupload的文件上传组件,改进了上传速度

package nbfileupload; /* * 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. */ import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.UnsupportedEncodingException; import org.apache.commons.fileupload.ProgressListener; import org.apache.commons.fileupload.util.Closeable; import org.apache.commons.fileupload.util.Streams; /** * <p> Low level API for processing file uploads. * * <p> This class can be used to process data streams conforming to MIME * 'multipart' format as defined in * <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a>. Arbitrarily * large amounts of data in the stream can be processed under constant * memory usage. * * <p> The format of the stream is defined in the following way:<br> * * <code> * multipart-body := preamble 1*encapsulation close-delimiter epilogue<br> * encapsulation := delimiter body CRLF<br> * delimiter := "--" boundary CRLF<br> * close-delimiter := "--" boudary "--"<br> * preamble := &lt;ignore&gt;<br> * epilogue := &lt;ignore&gt;<br> * body := header-part CRLF body-part<br> * header-part := 1*header CRLF<br> * header := header-name ":" header-value<br> * header-name := &lt;printable ascii characters except ":"&gt;<br> * header-value := &lt;any ascii characters except CR & LF&gt;<br> * body-data := &lt;arbitrary data&gt;<br> * </code> * * <p>Note that body-data can contain another mulipart entity. There * is limited support for single pass processing of such nested * streams. The nested stream is <strong>required</strong> to have a * boundary token of the same length as the parent stream (see {@link * #setBoundary(byte[])}). * * <p>Here is an example of usage of this class.<br> * * <pre> * try { * MultipartStream multipartStream = new MultipartStream(input, boundary); * boolean nextPart = multipartStream.skipPreamble(); * OutputStream output; * while(nextPart) { * String header = multipartStream.readHeaders(); * // process headers * // create some output stream * multipartStream.readBodyData(output); * nextPart = multipartStream.readBoundary(); * } * } catch(MultipartStream.MalformedStreamException e) { * // the stream failed to follow required syntax * } catch(IOException e) { * // a read or write error occurred * } * </pre> * * @author <a href="mailto:Rafal.Krzewski@e-point.pl">Rafal Krzewski</a> * @author <a href="mailto:martinc@apache.org">Martin Cooper</a> * @author Sean C. Sullivan * * @version $Id: MultipartStream.java 735374 2009-01-18 02:18:45Z jochen $ */ public class MultipartStream { /** * Internal class, which is used to invoke the * {@link ProgressListener}. */ public static class ProgressNotifier { /** The listener to invoke. */ private final ProgressListener listener; /** Number of expected bytes, if known, or -1. */ private final long contentLength; /** Number of bytes, which have been read so far. */ private long bytesRead; /** Number of items, which have been read so far. */ private int items; /** Creates a new instance with the given listener * and content length. * @param pListener The listener to invoke. * @param pContentLength The expected content length. */ ProgressNotifier(ProgressListener pListener, long pContentLength) { listener = pListener; contentLength = pContentLength; } /** Called to indicate that bytes have been read. * @param pBytes Number of bytes, which have been read. */ void noteBytesRead(int pBytes) { /* Indicates, that the given number of bytes have been read from * the input stream. */ bytesRead += pBytes; notifyListener(); } /** Called to indicate, that a new file item has been detected. */ void noteItem() { ++items; notifyListener(); } /** Called for notifying the listener. */ private void notifyListener() { if (listener != null) { listener.update(bytesRead, contentLength, items); } } } // ----------------------------------------------------- Manifest constants /** * The Carriage Return ASCII character value. */ public static final byte CR = 0x0D; /** * The Line Feed ASCII character value. */ public static final byte LF = 0x0A; /** * The dash (-) ASCII character value. */ public static final byte DASH = 0x2D; /** * The maximum length of <code>header-part</code> that will be * processed (10 kilobytes = 10240 bytes.). */ public static final int HEADER_PART_SIZE_MAX = 10240; /** * The default length of the buffer used for processing a request. */ protected static final int DEFAULT_BUFSIZE = 4096; /** * A byte sequence that marks the end of <code>header-part</code> * (<code>CRLFCRLF</code>). */ protected static final byte[] HEADER_SEPARATOR = { CR, LF, CR, LF }; /** * A byte sequence that that follows a delimiter that will be * followed by an encapsulation (<code>CRLF</code>). */ protected static final byte[] FIELD_SEPARATOR = { CR, LF}; /** * A byte sequence that that follows a delimiter of the last * encapsulation in the stream (<code>--</code>). */ protected static final byte[] STREAM_TERMINATOR = { DASH, DASH}; /** * A byte sequence that precedes a boundary (<code>CRLF--</code>). */ protected static final byte[] BOUNDARY_PREFIX = { CR, LF, DASH, DASH}; // ----------------------------------------------------------- Data members /** * The input stream from which data is read. */ private final InputStream input; /** * The length of the boundary token plus the leading <code>CRLF--</code>. */ private int boundaryLength; /** * The amount of data, in bytes, that must be kept in the buffer in order * to detect delimiters reliably. */ private int keepRegion; /** * The byte sequence that partitions the stream. */ private byte[] boundary; /** * The length of the buffer used for processing the request. */ private final int bufSize; /** * The buffer used for processing the request. */ private final byte[] buffer; /** * The index of first valid character in the buffer. * <br> * 0 <= head < bufSize */ private int head; /** * The index of last valid characer in the buffer + 1. * <br> * 0 <= tail <= bufSize */ pr