Java tutorial
/** * Copyright 2005-2010 hdiv.org * * 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.hdiv.web.multipart; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Hashtable; import java.util.Map; import javax.servlet.ServletContext; import javax.servlet.http.HttpServletRequest; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.hdiv.config.multipart.IMultipartConfig; import org.hdiv.filter.RequestWrapper; import org.springframework.util.Assert; import org.springframework.util.LinkedMultiValueMap; import org.springframework.util.MultiValueMap; import org.springframework.web.multipart.MaxUploadSizeExceededException; import org.springframework.web.multipart.MultipartException; import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartHttpServletRequest; import org.springframework.web.multipart.commons.CommonsMultipartFile; import org.springframework.web.multipart.commons.CommonsMultipartResolver; import org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest; /** * Servlet-based MultipartResolver implementation for * <a href="http://jakarta.apache.org/commons/fileupload">Jakarta Commons FileUpload</a> * 1.2 or higher and HDIV 2.06 or higher. * * <p>Provides maxUploadSize, maxInMemorySize, and defaultEncoding settings as * bean properties (inherited from CommonsFileUploadSupport). See respective * ServletFileUpload / DiskFileItemFactory properties (sizeMax, sizeThreshold, * headerEncoding) for details in terms of defaults and accepted values. * * <p>Saves temporary files to the servlet container's temporary directory. * Needs to be initialized <i>either</i> by an application context <i>or</i> * via the constructor that takes a ServletContext (for standalone usage). * * <p><b>NOTE:</b> As of Spring 2.0, this multipart resolver requires * Commons FileUpload 1.1 or higher. The implementation does not use * any deprecated FileUpload 1.0 API anymore, to be compatible with future * Commons FileUpload releases. * * @author Gorka Vicente * @since HDIV 2.0.6 * @see #CommonsMultipartResolver(ServletContext) * @see CommonsMultipartFile * @see org.springframework.web.portlet.multipart.PortletMultipartResolver * @see org.apache.commons.fileupload.servlet.ServletFileUpload * @see org.apache.commons.fileupload.disk.DiskFileItemFactory */ public class HDIVMultipartResolver extends CommonsMultipartResolver { private static Log log = LogFactory.getLog(HDIVMultipartResolver.class); private boolean resolveLazily = false; @Override public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException { Assert.notNull(request, "Request must not be null"); if (request instanceof RequestWrapper) { final RequestWrapper requestWrapper = (RequestWrapper) request; Exception multipartException = (Exception) request.getAttribute(IMultipartConfig.FILEUPLOAD_EXCEPTION); if (multipartException != null) { if (multipartException instanceof MaxUploadSizeExceededException) { throw (MaxUploadSizeExceededException) multipartException; } else { throw new MultipartException("Could not parse multipart servlet request", multipartException); } } if (this.resolveLazily) { return new DefaultMultipartHttpServletRequest(requestWrapper) { @Override protected void initializeMultipart() { setMultipartFiles(getMultipartFileElements(requestWrapper.getFileElements())); setMultipartParameters(getMultipartTextElements(requestWrapper.getTextElements())); } }; } else { return new DefaultMultipartHttpServletRequest(request, getMultipartFileElements(requestWrapper.getFileElements()), getMultipartTextElements(requestWrapper.getTextElements())); } } else { //The normal behaviour return super.resolveMultipart(request); } } /** * Return the multipart files as Map of field name to MultipartFile instance. */ public MultiValueMap<String, MultipartFile> getMultipartFileElements(Hashtable fileElements) { MultiValueMap<String, MultipartFile> multipartFiles = new LinkedMultiValueMap<String, MultipartFile>(); for (Object key : fileElements.keySet()) { multipartFiles.add((String) key, (MultipartFile) fileElements.get(key)); } return multipartFiles; } /** * Return the multipart parameters as Map of field name to form field String value. */ public Map<String, String[]> getMultipartTextElements(Hashtable textElements) { Map<String, String[]> multipartParameters = new HashMap<String, String[]>(); multipartParameters.putAll(textElements); return multipartParameters; } /** * Return the multipart files as Map of field name to MultipartFile instance. */ public Collection<MultipartFile> getMultipartFileValues(Hashtable fileElements) { Collection<MultipartFile> multipartFileValues = new ArrayList<MultipartFile>(); multipartFileValues.addAll(fileElements.values()); return multipartFileValues; } @Override public void cleanupMultipart(MultipartHttpServletRequest request) { if (request != null) { DefaultMultipartHttpServletRequest defaultRequest = (DefaultMultipartHttpServletRequest) request; RequestWrapper requestWrapper = (RequestWrapper) defaultRequest.getRequest(); //Call to the original method this.cleanupFileItems(getMultipartFileElements(requestWrapper.getFileElements())); } } /** * Set whether to resolve the multipart request lazily at the time of * file or parameter access. * <p>Default is "false", resolving the multipart elements immediately, throwing * corresponding exceptions at the time of the {@link #resolveMultipart} call. * Switch this to "true" for lazy multipart parsing, throwing parse exceptions * once the application attempts to obtain multipart files or parameters. */ public void setResolveLazily(boolean resolveLazily) { super.setResolveLazily(resolveLazily); this.resolveLazily = resolveLazily; } }