Example usage for org.springframework.web.multipart.support DefaultMultipartHttpServletRequest DefaultMultipartHttpServletRequest

Introduction

In this page you can find the example usage for org.springframework.web.multipart.support DefaultMultipartHttpServletRequest DefaultMultipartHttpServletRequest.

Prototype

public DefaultMultipartHttpServletRequest(HttpServletRequest request,
        MultiValueMap<String, MultipartFile> mpFiles, Map<String, String[]> mpParams,
        Map<String, String> mpParamContentTypes) 

Source Link

Document

Wrap the given HttpServletRequest in a MultipartHttpServletRequest.

Usage

From source file:ru.arch_timeline.spring.multipart.StreamingMultipartResolver.java

public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException {

    // Create a new file upload handler
    ServletFileUpload upload = new ServletFileUpload();
    upload.setFileSizeMax(maxUploadSize);

    String encoding = determineEncoding(request);

    //Map<String, MultipartFile> multipartFiles = new HashMap<String, MultipartFile>();
    Map<String, String[]> multipartParameters = new HashMap<String, String[]>();
    Map<String, String> multipartContentTypes = new HashMap<String, String>();

    MultiValueMap<String, MultipartFile> multipartFiles = new LinkedMultiValueMap<String, MultipartFile>();

    // Parse the request
    try {/* w ww.j av a  2s .  c  o m*/
        FileItemIterator iter = upload.getItemIterator(request);
        while (iter.hasNext()) {
            FileItemStream item = iter.next();

            String name = item.getFieldName();
            InputStream stream = item.openStream();
            if (item.isFormField()) {

                String value = Streams.asString(stream, encoding);

                String[] curParam = (String[]) multipartParameters.get(name);
                if (curParam == null) {
                    // simple form field
                    multipartParameters.put(name, new String[] { value });
                } else {
                    // array of simple form fields
                    String[] newParam = StringUtils.addStringToArray(curParam, value);
                    multipartParameters.put(name, newParam);
                }

            } else {

                // Process the input stream
                MultipartFile file = new StreamingMultipartFile(item);
                multipartFiles.add(name, file);
                multipartContentTypes.put(name, file.getContentType());
            }
        }
    } catch (IOException e) {
        throw new MultipartException("something went wrong here", e);
    } catch (FileUploadException e) {
        throw new MultipartException("something went wrong here", e);
    }

    return new DefaultMultipartHttpServletRequest(request, multipartFiles, multipartParameters,
            multipartContentTypes);
}

---

From source file:org.tangram.spring.StreamingMultipartResolver.java

@Override
public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException {
    ServletFileUpload upload = new ServletFileUpload();
    upload.setFileSizeMax(maxUploadSize);
    String encoding = determineEncoding(request);
    Map<String, String[]> multipartParameters = new HashMap<>();
    MultiValueMap<String, MultipartFile> multipartFiles = new LinkedMultiValueMap<>();
    Map<String, String> multipartFileContentTypes = new HashMap<>();

    try {//  w w w  .  j ava 2 s.c o  m
        FileItemIterator iter = upload.getItemIterator(request);
        while (iter.hasNext()) {
            FileItemStream item = iter.next();

            String name = item.getFieldName();
            InputStream stream = item.openStream();
            if (item.isFormField()) {
                String value = Streams.asString(stream, encoding);
                String[] curParam = multipartParameters.get(name);
                if (curParam == null) {
                    // simple form field
                    multipartParameters.put(name, new String[] { value });
                } else {
                    // array of simple form fields
                    String[] newParam = StringUtils.addStringToArray(curParam, value);
                    multipartParameters.put(name, newParam);
                }
            } else {
                try {
                    MultipartFile file = new StreamingMultipartFile(item);
                    multipartFiles.add(name, file);
                    multipartFileContentTypes.put(name, file.getContentType());
                } catch (final IOException e) {
                    LOG.warn("({})", e.getCause().getMessage(), e);
                    MultipartFile file = new MultipartFile() {

                        @Override
                        public String getName() {
                            return "";
                        }

                        @Override
                        public String getOriginalFilename() {
                            return e.getCause().getMessage();
                        }

                        @Override
                        public String getContentType() {
                            return ERROR;
                        }

                        @Override
                        public boolean isEmpty() {
                            return true;
                        }

                        @Override
                        public long getSize() {
                            return 0L;
                        }

                        @Override
                        public byte[] getBytes() throws IOException {
                            return new byte[0];
                        }

                        @Override
                        public InputStream getInputStream() throws IOException {
                            return null;
                        }

                        @Override
                        public void transferTo(File file) throws IOException, IllegalStateException {
                            throw new UnsupportedOperationException("NYI", e);
                        }
                    };
                    multipartFiles.add(name, file);
                    multipartFileContentTypes.put(name, file.getContentType());
                } // try/catch
            } // if
        } // while
    } catch (IOException | FileUploadException e) {
        throw new MultipartException("Error uploading a file", e);
    } // try/catch

    return new DefaultMultipartHttpServletRequest(request, multipartFiles, multipartParameters,
            multipartFileContentTypes);
}

---

From source file:ubic.gemma.web.util.upload.CommonsMultipartMonitoredResolver.java

@Override
public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException {
    String enc = determineEncoding(request);

    ServletFileUpload fileUpload = this.newFileUpload(request);
    DiskFileItemFactory newFactory = (DiskFileItemFactory) fileUpload.getFileItemFactory();
    fileUpload.setSizeMax(sizeMax);//from w  w  w.java2s . c  om
    newFactory.setRepository(this.uploadTempDir);
    fileUpload.setHeaderEncoding(enc);

    try {
        MultiValueMap<String, MultipartFile> multipartFiles = new LinkedMultiValueMap<>();
        Map<String, String[]> multipartParams = new HashMap<>();

        // Extract multipart files and multipart parameters.
        List<?> fileItems = fileUpload.parseRequest(request);
        for (Object fileItem1 : fileItems) {
            FileItem fileItem = (FileItem) fileItem1;
            if (fileItem.isFormField()) {
                String value;
                String fieldName = fileItem.getFieldName();

                try {
                    value = fileItem.getString(enc);
                } catch (UnsupportedEncodingException ex) {
                    logger.warn("Could not decode multipart item '" + fieldName + "' with encoding '" + enc
                            + "': using platform default");
                    value = fileItem.getString();
                }

                String[] curParam = multipartParams.get(fieldName);
                if (curParam == null) {
                    // simple form field
                    multipartParams.put(fieldName, new String[] { value });
                } else {
                    // array of simple form fields
                    String[] newParam = StringUtils.addStringToArray(curParam, value);
                    multipartParams.put(fieldName, newParam);
                }
            } else {
                // multipart file field
                MultipartFile file = new CommonsMultipartFile(fileItem);
                multipartFiles.set(file.getName(), file);
                if (logger.isDebugEnabled()) {
                    logger.debug("Found multipart file [" + file.getName() + "] of size " + file.getSize()
                            + " bytes with original filename [" + file.getOriginalFilename() + "]");
                }
            }
        }
        return new DefaultMultipartHttpServletRequest(request, multipartFiles, multipartParams, null);
    } catch (FileUploadException ex) {
        return new FailedMultipartHttpServletRequest(request, ex.getMessage());
    }
}

---

From source file:uk.ac.bbsrc.tgac.miso.spring.ajax.multipart.AjaxMultipartResolver.java

@Override
public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException {
    String encoding = determineEncoding(request);
    FileUpload fileUpload = prepareFileUpload(encoding);
    if (fileUploadListener != null) {
        fileUpload.setProgressListener(fileUploadListener);
        request.getSession(false).setAttribute("upload_listener", fileUploadListener);
    }//from   w w  w  .  j  a va2  s .  c o  m
    try {
        List fileItems = ((ServletFileUpload) fileUpload).parseRequest(request);
        MultipartParsingResult parsingResult = parseFileItems(fileItems, encoding);
        Map<String, String> multipartContentTypes = new HashMap<String, String>();
        for (List<MultipartFile> files : parsingResult.getMultipartFiles().values()) {
            for (MultipartFile f : files) {
                multipartContentTypes.put(f.getName(), f.getContentType());
            }
        }
        return new DefaultMultipartHttpServletRequest(request, parsingResult.getMultipartFiles(),
                parsingResult.getMultipartParameters(), multipartContentTypes);
    } catch (FileUploadBase.SizeLimitExceededException ex) {
        throw new MaxUploadSizeExceededException(fileUpload.getSizeMax(), ex);
    } catch (FileUploadException ex) {
        throw new MultipartException("Could not parse multipart servlet request", ex);
    }
}

---