Java tutorial
/** * Copyright 2011 meltmedia * * Licensed 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.xchain.framework.servlet; import org.apache.commons.fileupload.disk.DiskFileItemFactory; import org.apache.commons.fileupload.servlet.ServletFileUpload; import org.apache.commons.fileupload.FileItem; import org.apache.commons.fileupload.FileUploadException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.servlet.http.HttpServletRequestWrapper; import javax.servlet.http.HttpServletRequest; import java.util.List; import java.util.Map; import java.util.HashMap; import java.util.ArrayList; import java.util.Iterator; import java.util.Enumeration; import java.io.File; import java.lang.reflect.Array; /** * * This code was adapted from code originally written by Darius Robinson. * * @author Darius Robinson * @author Christian Trimble * @author John Trimble * @author Josh Kennedy * @version 1.0 */ public class MultipartFormDataServletRequest extends HttpServletRequestWrapper { public static Logger log = LoggerFactory.getLogger(MultipartFormDataServletRequest.class); private Map<String, String[]> parameterMap = new HashMap<String, String[]>(); private Map<String, FileItem[]> fileItemMap = new HashMap<String, FileItem[]>(); public MultipartFormDataServletRequest(HttpServletRequest request, long maxSize, int sizeThreshold, String repositoryPath) throws FileUploadException { super(request); // Create the disk file item factory. DiskFileItemFactory factory = createDiskFileItemFactory(sizeThreshold, repositoryPath); ServletFileUpload servletFileUpload = new ServletFileUpload(factory); // maximum size before a FileUploadException will be thrown servletFileUpload.setSizeMax(maxSize); // parse the request. Iterator<FileItem> fileItemIterator = servletFileUpload.parseRequest(request).iterator(); // Oye! Unchecked type conversion. // create temporary maps for parameters and file items. Map<String, List<String>> parameterMap = new HashMap<String, List<String>>(); Map<String, List<FileItem>> fileItemMap = new HashMap<String, List<FileItem>>(); // populate the maps. while (fileItemIterator.hasNext()) { FileItem fileItem = fileItemIterator.next(); if (fileItem.isFormField()) { putListMapValue(parameterMap, fileItem.getFieldName(), fileItem.getString()); } else { putListMapValue(fileItemMap, fileItem.getFieldName(), fileItem); } } // convert the array lists. convertListMapToArrayMap(parameterMap, this.parameterMap, String.class); convertListMapToArrayMap(fileItemMap, this.fileItemMap, FileItem.class); if (log.isDebugEnabled()) { logFileItemMap(); } } public FileItem getFileItem(String name) { FileItem fileItem = null; FileItem[] fileItemArray = (FileItem[]) fileItemMap.get(name); if (fileItemArray != null) fileItem = fileItemArray[0]; return fileItem; } public Enumeration<String> getFileItemNames() { return new IteratorEnumeration<String>(fileItemMap.keySet().iterator()); } public Map<String, FileItem[]> getFileItemMap() { return fileItemMap; } public FileItem[] getFileItemValues(String name) { return (FileItem[]) fileItemMap.get(name); } public String getParameter(String name) { String parameter = null; String[] parameterList = (String[]) parameterMap.get(name); if (parameterList != null && parameterList.length > 0) { parameter = parameterList[0]; } return parameter; } public Enumeration<String> getParameterNames() { return new IteratorEnumeration<String>(parameterMap.keySet().iterator()); } public Map<String, String[]> getParameterMap() { return parameterMap; } public String[] getParameterValues(String name) { return (String[]) parameterMap.get(name); } private static <K, V> Map<K, V[]> convertListMapToArrayMap(Map<K, List<V>> listMap, Map<K, V[]> arrayMap, Class<V> elementType) { if (arrayMap == null) arrayMap = new HashMap<K, V[]>(); for (Map.Entry<K, List<V>> e : listMap.entrySet()) { V[] valueArray = (V[]) Array.newInstance(elementType, e.getValue().size()); arrayMap.put(e.getKey(), e.getValue().toArray(valueArray)); } return arrayMap; } private static <K, V> void putListMapValue(Map<K, List<V>> map, K key, V value) { List<V> valueArray = map.get(key); if (valueArray == null) { valueArray = new ArrayList<V>(); map.put(key, valueArray); } valueArray.add(value); } private static DiskFileItemFactory createDiskFileItemFactory(int sizeThreshold, String repositoryPath) throws FileUploadException { DiskFileItemFactory factory = new DiskFileItemFactory(); // the location for saving data that is larger than getSizeThreshold() File repository = new File(repositoryPath); factory.setRepository(repository); // maximum size that will be stored in memory factory.setSizeThreshold(sizeThreshold); // Check to see if repository exists; if not, try to create it; if this fails, throw an exception. if (repository.exists()) { if (!repository.isDirectory()) { throw new FileUploadException("Cannot upload files because the specified temporary " + "directory is of type file. (" + repository.getAbsolutePath() + ")"); } } else if (!repository.mkdir()) { throw new FileUploadException("Cannot upload files because the specified temporary " + " does not exist, and attempts to create it have failed. (" + repository.getAbsolutePath() + ")"); } return factory; } protected void logFileItemMap() { log.debug("File item map has " + fileItemMap.keySet().size() + " keys."); Iterator<Map.Entry<String, FileItem[]>> entryIterator = fileItemMap.entrySet().iterator(); while (entryIterator.hasNext()) { Map.Entry<String, FileItem[]> entry = entryIterator.next(); String key = entry.getKey(); FileItem[] fileItems = entry.getValue(); log.debug("Key '" + key + "' has " + fileItems.length + " entries."); for (int i = 0; i < fileItems.length; i++) { log.debug("Name='" + fileItems[i].getName() + "', size=" + fileItems[i].getSize() + ", content-type='" + fileItems[i].getContentType() + "'"); } } } } class IteratorEnumeration<T> implements Enumeration<T> { Iterator<T> wrappedIterator = null; public IteratorEnumeration(Iterator<T> wrappedIterator) { this.wrappedIterator = wrappedIterator; } public boolean hasMoreElements() { return wrappedIterator.hasNext(); } public T nextElement() { return wrappedIterator.next(); } }