commonsmultipartrequesthandler.java

structs源码

/*
 * $Id: CommonsMultipartRequestHandler.java 471754 2006-11-06 14:55:09Z husted $
 *
 * 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.struts.upload;

import org.apache.commons.fileupload.DiskFileUpload;
import org.apache.commons.fileupload.disk.DiskFileItem;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts.Globals;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionServlet;
import org.apache.struts.config.ModuleConfig;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;

/**
 * <p> This class implements the <code>MultipartRequestHandler</code>
 * interface by providing a wrapper around the Jakarta Commons FileUpload
 * library. </p>
 *
 * @version $Rev: 471754 $ $Date: 2006-11-06 08:55:09 -0600 (Mon, 06 Nov 2006) $
 * @since Struts 1.1
 */
public class CommonsMultipartRequestHandler implements MultipartRequestHandler {
    // ----------------------------------------------------- Manifest Constants

    /**
     * <p> The default value for the maximum allowable size, in bytes, of an
     * uploaded file. The value is equivalent to 250MB. </p>
     */
    public static final long DEFAULT_SIZE_MAX = 250 * 1024 * 1024;

    /**
     * <p> The default value for the threshold which determines whether an
     * uploaded file will be written to disk or cached in memory. The value is
     * equivalent to 250KB. </p>
     */
    public static final int DEFAULT_SIZE_THRESHOLD = 256 * 1024;

    // ----------------------------------------------------- Instance Variables

    /**
     * <p> Commons Logging instance. </p>
     */
    protected static Log log =
        LogFactory.getLog(CommonsMultipartRequestHandler.class);

    /**
     * <p> The combined text and file request parameters. </p>
     */
    private Hashtable elementsAll;

    /**
     * <p> The file request parameters. </p>
     */
    private Hashtable elementsFile;

    /**
     * <p> The text request parameters. </p>
     */
    private Hashtable elementsText;

    /**
     * <p> The action mapping  with which this handler is associated. </p>
     */
    private ActionMapping mapping;

    /**
     * <p> The servlet with which this handler is associated. </p>
     */
    private ActionServlet servlet;

    // ---------------------------------------- MultipartRequestHandler Methods

    /**
     * <p> Retrieves the servlet with which this handler is associated. </p>
     *
     * @return The associated servlet.
     */
    public ActionServlet getServlet() {
        return this.servlet;
    }

    /**
     * <p> Sets the servlet with which this handler is associated. </p>
     *
     * @param servlet The associated servlet.
     */
    public void setServlet(ActionServlet servlet) {
        this.servlet = servlet;
    }

    /**
     * <p> Retrieves the action mapping with which this handler is associated.
     * </p>
     *
     * @return The associated action mapping.
     */
    public ActionMapping getMapping() {
        return this.mapping;
    }

    /**
     * <p> Sets the action mapping with which this handler is associated.
     * </p>
     *
     * @param mapping The associated action mapping.
     */
    public void setMapping(ActionMapping mapping) {
        this.mapping = mapping;
    }

    /**
     * <p> Parses the input stream and partitions the parsed items into a set
     * of form fields and a set of file items. In the process, the parsed
     * items are translated from Commons FileUpload <code>FileItem</code>
     * instances to Struts <code>FormFile</code> instances. </p>
     *
     * @param request The multipart request to be processed.
     * @throws ServletException if an unrecoverable error occurs.
     */
    public void handleRequest(HttpServletRequest request)
        throws ServletException {
        // Get the app config for the current request.
        ModuleConfig ac =
            (ModuleConfig) request.getAttribute(Globals.MODULE_KEY);

        // Create and configure a DIskFileUpload instance.
        DiskFileUpload upload = new DiskFileUpload();

        // The following line is to support an "EncodingFilter"
        // see http://issues.apache.org/bugzilla/show_bug.cgi?id=23255
        upload.setHeaderEncoding(request.getCharacterEncoding());

        // Set the maximum size before a FileUploadException will be thrown.
        upload.setSizeMax(getSizeMax(ac));

        // Set the maximum size that will be stored in memory.
        upload.setSizeThreshold((int) getSizeThreshold(ac));

        // Set the the location for saving data on disk.
        upload.setRepositoryPath(getRepositoryPath(ac));

        // Create the hash tables to be populated.
        elementsText = new Hashtable();
        elementsFile = new Hashtable();
        elementsAll = new Hashtable();

        // Parse the request into file items.
        List items = null;

        try {
            items = upload.parseRequest(request);
        } catch (DiskFileUpload.SizeLimitExceededException e) {
            // Special handling for uploads that are too big.
            request.setAttribute(MultipartRequestHandler.ATTRIBUTE_MAX_LENGTH_EXCEEDED,
                Boolean.TRUE);

            return;
        } catch (FileUploadException e) {
            log.error("Failed to parse multipart request", e);
            throw new ServletException(e);
        }

        // Partition the items into form fields and files.
        Iterator iter = items.iterator();

        while (iter.hasNext()) {
            FileItem item = (FileItem) iter.next();

            if (item.isFormField()) {
                addTextParameter(request, item);
            } else {
                addFileParameter(item);
            }
        }
    }

    /**
     * <p> Returns a hash table containing the text (that is, non-file)
     * request parameters. </p>
     *
     * @return The text request parameters.
     */
    public Hashtable getTextElements() {
        return this.elementsText;
    }

    /**
     * <p> Returns a hash table containing the file (that is, non-text)
     * request parameters. </p>
     *
     * @return The file request parameters.
     */
    public Hashtable getFileElements() {
        return this.elementsFile;
    }

    /**
     * <p> Returns a hash table containing both text and file request
     * parameters. </p>
     *
     * @return The text and file request parameters.
     */
    public Hashtable getAllElements() {
        return this.elementsAll;
    }

    /**
     * <p> Cleans up when a problem occurs during request processing. </p>
     */
    public void rollback() {
        Iterator iter = elementsFile.values().iterator();

        while (iter.hasNext()) {
            FormFile formFile = (FormFile) iter.next();

            formFile.destroy();
        }
    }

    /**
     * <p> Cleans up at the end of a request. </p>
     */
    public void finish() {
        rollback();
    }

    // -------------------------------------------------------- Support Methods

    /**
     * <p> Returns the maximum allowable size, in bytes, of an uploaded file.
     * The value is obtained from the current module's controller
     * configuration. </p>
     *
     * @param mc The current module's configuration.
     * @return The maximum allowable file size, in bytes.
     */
    protected long getSizeMax(ModuleConfig mc) {
        return convertSizeToBytes(mc.getControllerConfig().getMaxFileSize(),
            DEFAULT_SIZE_MAX);
    }

    /**
     * <p> Returns the size threshold which determines whether an uploaded
     * file will be written to disk or cached in memory. </p>
     *
     * @param mc The current module's configuration.
     * @return The size threshold, in bytes.
     */
    protected long getSizeThreshold(ModuleConfig mc) {
        return convertSizeToBytes(mc.getControllerConfig().getMemFileSize(),
            DEFAULT_SIZE_THRESHOLD);
    }

    /**
     * <p> Converts a size value from a string representation to its numeric
     * value. The string must be of the form nnnm, where nnn is an arbitrary
     * decimal value, and m is a multiplier. The multiplier must be one of
     * 'K', 'M' and 'G', representing kilobytes, megabytes and gigabytes
     * respectively. </p><p> If the size value cannot be converted, for
     * example due to invalid syntax, the supplied default is returned
     * instead. </p>
     *
     * @param sizeString  The string representation of the size to be
     *                    converted.
     * @param defaultSize The value to be returned if the string is invalid.
     * @return The actual size in bytes.
     */
    protected long convertSizeToBytes(String sizeString, long defaultSize) {
        int multiplier = 1;

        if (sizeString.endsWith("K")) {
            multiplier = 1024;
        } else if (sizeString.endsWith("M")) {
            multiplier = 1024 * 1024;
        } else if (sizeString.endsWith("G")) {
            multiplier = 1024 * 1024 * 1024;
        }