Java tutorial
/* * 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.jackrabbit.server.util; import org.apache.commons.fileupload.FileItem; import org.apache.commons.fileupload.FileItemFactory; import org.apache.commons.fileupload.FileUploadException; import org.apache.commons.fileupload.disk.DiskFileItemFactory; import org.apache.commons.fileupload.servlet.ServletFileUpload; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.servlet.http.HttpServletRequest; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; /** * <code>HttpMultipartPost</code>... */ class HttpMultipartPost { /** * logger instance */ private static final Logger log = LoggerFactory.getLogger(HttpMultipartPost.class); private final Map<String, List<FileItem>> nameToItems = new LinkedHashMap<String, List<FileItem>>(); private final Set<String> fileParamNames = new HashSet<String>(); private boolean initialized; HttpMultipartPost(HttpServletRequest request, File tmpDir) throws IOException { extractMultipart(request, tmpDir); initialized = true; } /** * * @param tmpDir * @return */ private static FileItemFactory getFileItemFactory(File tmpDir) { DiskFileItemFactory fiFactory = new DiskFileItemFactory(DiskFileItemFactory.DEFAULT_SIZE_THRESHOLD, tmpDir); return fiFactory; } /** * * @param request * @param tmpDir * @throws IOException */ private void extractMultipart(HttpServletRequest request, File tmpDir) throws IOException { if (!ServletFileUpload.isMultipartContent(request)) { log.debug("Request does not contain multipart content -> ignoring."); return; } ServletFileUpload upload = new ServletFileUpload(getFileItemFactory(tmpDir)); // make sure the content disposition headers are read with the charset // specified in the request content type (or UTF-8 if no charset is specified). // see JCR if (request.getCharacterEncoding() == null) { upload.setHeaderEncoding("UTF-8"); } try { @SuppressWarnings("unchecked") List<FileItem> fileItems = upload.parseRequest(request); for (FileItem fileItem : fileItems) { addItem(fileItem); } } catch (FileUploadException e) { log.error("Error while processing multipart.", e); throw new IOException(e.toString()); } } /** * Add the given file item to the list defined for its name and make the * list is present in the map. If the item does not represent a simple * form field its name is also added to the <code>fileParamNames</code> set. * * @param item The {@link FileItem} to add. */ private void addItem(FileItem item) { String name = item.getFieldName(); List<FileItem> l = nameToItems.get(item.getFieldName()); if (l == null) { l = new ArrayList<FileItem>(); nameToItems.put(name, l); } l.add(item); // if file parameter, add name to the set of file parameters in order to // be able to extract the file parameter values later on without iterating // over all keys. if (!item.isFormField()) { fileParamNames.add(name); } } private void checkInitialized() { if (!initialized) { throw new IllegalStateException("HttpMultipartPost not initialized (or already disposed)."); } } /** * Release all file items hold with the name-to-items map. specially those * having a tmp-file associated with. * * @see FileItem#delete() */ synchronized void dispose() { checkInitialized(); for (List<FileItem> fileItems : nameToItems.values()) { for (FileItem fileItem : fileItems) { fileItem.delete(); } } nameToItems.clear(); fileParamNames.clear(); initialized = false; } /** * Returns an iterator over all file item names. * * @return a set of strings. */ Set<String> getParameterNames() { checkInitialized(); return nameToItems.keySet(); } /** * Returns the content types of the paramaters with the given name. If * the parameter does not exist <code>null</code> is returned. If the content * type of any of the parameter values is not known, the corresponding entry * in the array returned is <code>null</code>. * <p> * The content type of a paramater is only known here if the information * has been sent by the client browser. This is generally only the case * for file upload fields of HTML forms which have been posted using the * HTTP <em>POST</em> with <em>multipart/form-data</em> encoding. * <p> * Example : For the form * <pre> <form name="Upload" method="POST" ENCTYPE="multipart/form-data"> <input type="file" name="Upload"><br> <input type="text" name="Upload"><br> <input type="submit"> </form> * </pre> * this method will return an array of two entries when called for the * <em>Upload</em> parameter. The first entry will contain the content * type (if transmitted by the client) of the file uploaded. The second * entry will be <code>null</code> because the content type of the text * input field will generally not be sent by the client. * * @param name The name of the paramater whose content type is to be * returned. * @return The content types of the file items with the specified name. */ String[] getParameterTypes(String name) { checkInitialized(); String[] cts = null; List<FileItem> l = nameToItems.get(name); if (l != null && !l.isEmpty()) { cts = new String[l.size()]; for (int i = 0; i < cts.length; i++) { cts[i] = l.get(i).getContentType(); } } return cts; } /** * Returns the first value of the file items with the given <code>name</code>. * The byte to string converstion is done using either the contenttype of * the file items or the <code>formEncoding</code>. * <p/> * Please note that if the addressed parameter is an uploaded file rather * than a simple form entry, the name of the original file is returned * instead of the content. * * @param name the name of the parameter * @return the string of the first value or <code>null</code> if the * parameter does not exist */ String getParameter(String name) { checkInitialized(); List<FileItem> l = nameToItems.get(name); if (l == null || l.isEmpty()) { return null; } else { FileItem item = l.get(0); if (item.isFormField()) { return item.getString(); } else { return item.getName(); } } } /** * Returns an array of Strings with all values of the parameter addressed * by <code>name</code>. the byte to string conversion is done using either * the content type of the multipart body or the <code>formEncoding</code>. * <p/> * Please note that if the addressed parameter is an uploaded file rather * than a simple form entry, the name of the original file is returned * instead of the content. * * @param name the name of the parameter * @return a string array of values or <code>null</code> if no entry with the * given name exists. */ String[] getParameterValues(String name) { checkInitialized(); List<FileItem> l = nameToItems.get(name); if (l == null || l.isEmpty()) { return null; } else { String[] values = new String[l.size()]; for (int i = 0; i < values.length; i++) { FileItem item = l.get(i); if (item.isFormField()) { values[i] = item.getString(); } else { values[i] = item.getName(); } } return values; } } /** * Returns a set of the file parameter names. An empty set if * no file parameters were present in the request. * * @return an set of file item names representing the file * parameters available with the request. */ Set<String> getFileParameterNames() { checkInitialized(); return fileParamNames; } /** * Returns an array of input streams for uploaded file parameters. * * @param name the name of the file parameter(s) * @return an array of input streams or <code>null</code> if no file params * with the given name exist. * @throws IOException if an I/O error occurs */ InputStream[] getFileParameterValues(String name) throws IOException { checkInitialized(); InputStream[] values = null; if (fileParamNames.contains(name)) { List<FileItem> l = nameToItems.get(name); if (l != null && !l.isEmpty()) { List<InputStream> ins = new ArrayList<InputStream>(l.size()); for (FileItem item : l) { if (!item.isFormField()) { ins.add(item.getInputStream()); } } values = ins.toArray(new InputStream[ins.size()]); } } return values; } }