public String getMultipartContentType(String paramOrFileName){
  try {
    Part part=getPart(paramOrFileName);
    return (part != null ? part.getContentType() : null);
  }
 catch (  Exception ex) {
    throw new MultipartException("Could not access multipart servlet request",ex);
  }
}

public HttpHeaders getMultipartHeaders(String paramOrFileName){
  try {
    Part part=getPart(paramOrFileName);
    if (part != null) {
      HttpHeaders headers=new HttpHeaders();
      for (      String headerName : part.getHeaderNames()) {
        headers.put(headerName,new ArrayList<String>(part.getHeaders(headerName)));
      }
      return headers;
    }
 else {
      return null;
    }
  }
 catch (  Exception ex) {
    throw new MultipartException("Could not access multipart servlet request",ex);
  }
}

/** 
 * Reads the HttpServletRequest for a key-value pair and returns the value where the key is equal to the given key.
 * @param httpRequest A "multipart/form-data" request that contains the parameter that has a key value ‘key‘.
 * @param key The key for the value we are after in the ‘httpRequest‘.
 * @return Returns null if there is no such key in the request or if, after reading the object, it has a length of 0. Otherwise, it returns the value associated with the key as a byte array.
 * @throws ServletException Thrown if the ‘httpRequest‘ is not a "multipart/form-data" request.
 * @throws IOException Thrown if there is an error reading the value fromthe request‘s input stream.
 * @throws IllegalStateException Thrown if the entire request is largerthan the maximum allowed size for a  request or if the value of the requested key is larger than the maximum allowed  size for a single value.
 */
protected byte[] getMultipartValue(HttpServletRequest httpRequest,String key) throws ValidationException {
  try {
    Part part=httpRequest.getPart(key);
    if (part == null) {
      return null;
    }
    InputStream partInputStream=part.getInputStream();
    ByteArrayOutputStream outputStream=new ByteArrayOutputStream();
    byte[] chunk=new byte[4096];
    int amountRead;
    while ((amountRead=partInputStream.read(chunk)) != -1) {
      outputStream.write(chunk,0,amountRead);
    }
    if (outputStream.size() == 0) {
      return null;
    }
 else {
      return outputStream.toByteArray();
    }
  }
 catch (  ServletException e) {
    LOGGER.error("This is not a multipart/form-data POST.",e);
    setFailed(ErrorCode.SYSTEM_GENERAL_ERROR,"This is not a multipart/form-data POST which is what we expect for the current API call.");
    throw new ValidationException(e);
  }
catch (  IOException e) {
    LOGGER.error("There was an error reading the message from the input stream.",e);
    setFailed();
    throw new ValidationException(e);
  }
}

/** 
 * Reads the HttpServletRequest for a key-value pair and returns the value where the key is equal to the given key.
 * @param httpRequest A "multipart/form-data" request that contains the parameter that has a key value ‘key‘.
 * @param key The key for the value we are after in the ‘httpRequest‘.
 * @return Returns null if there is no such key in the request or if, after reading the object, it has a length of 0. Otherwise, it returns the value associated with the key as a byte array.
 * @throws ServletException Thrown if the ‘httpRequest‘ is not a "multipart/form-data" request.
 * @throws IOException Thrown if there is an error reading the value fromthe request‘s input stream.
 * @throws IllegalStateException Thrown if the entire request is largerthan the maximum allowed size for a  request or if the value of the requested key is larger than the maximum allowed  size for a single value.
 */
protected byte[] getMultipartValue(HttpServletRequest httpRequest,String key) throws ValidationException {
  try {
    Part part=httpRequest.getPart(key);
    if (part == null) {
      return null;
    }
    InputStream partInputStream=part.getInputStream();
    ByteArrayOutputStream outputStream=new ByteArrayOutputStream();
    byte[] chunk=new byte[4096];
    int amountRead;
    while ((amountRead=partInputStream.read(chunk)) != -1) {
      outputStream.write(chunk,0,amountRead);
    }
    if (outputStream.size() == 0) {
      return null;
    }
 else {
      return outputStream.toByteArray();
    }
  }
 catch (  ServletException e) {
    LOGGER.error("This is not a multipart/form-data POST.",e);
    setFailed(ErrorCodes.SYSTEM_GENERAL_ERROR,"This is not a multipart/form-data POST which is what we expect for the current API call.");
    throw new ValidationException(e);
  }
catch (  IOException e) {
    LOGGER.error("There was an error reading the message from the input stream.",e);
    setFailed();
    throw new ValidationException(e);
  }
}

/** 
 * @param part
 * @return
 */
public String getParameterFilename(Part part){
  for (  String cd : part.getHeader("content-disposition").split(";")) {
    if (cd.trim().startsWith("filename")) {
      String fileName=cd.substring(cd.indexOf(‘=‘) + 1).trim().replace("\"","");
      fileName=fileName.substring(fileName.lastIndexOf(‘/‘) + 1).substring(fileName.lastIndexOf(‘\\‘) + 1);
      return fileName;
    }
  }
  return null;
}

public void storeUploadedBlobs(HttpServletRequest request) throws IOException, ServletException {
  Map<String,BlobKey> map=new HashMap<String,BlobKey>();
  Map<String,List<BlobKey>> map2=new HashMap<String,List<BlobKey>>();
  for (  Part part : request.getParts()) {
    if (ServletUtils.isFile(part)) {
      BlobKey blobKey=storeUploadedBlob(part);
      String name=part.getName();
      map.put(name,blobKey);
      List<BlobKey> list=map2.get(name);
      if (list == null) {
        list=new LinkedList<BlobKey>();
        map2.put(name,list);
      }
      list.add(blobKey);
    }
  }
  request.setAttribute(UPLOADED_BLOBKEY_ATTR,map);
  request.setAttribute(UPLOADED_BLOBKEY_LIST_ATTR,map2);
}

private BlobKey storeUploadedBlob(Part part) throws IOException {
  JBossFileService fileService=getFileService();
  AppEngineFile file=fileService.createNewBlobFile(part.getContentType(),ServletUtils.getFileName(part));
  ReadableByteChannel in=Channels.newChannel(part.getInputStream());
  try {
    FileWriteChannel out=fileService.openWriteChannel(file,true);
    try {
      IOUtils.copy(in,out);
    }
  finally {
      out.closeFinally();
    }
  }
  finally {
    in.close();
  }
  return fileService.getBlobKey(file);
}

public static String getFileName(Part part){
  String contentDisposition=part.getHeader("content-disposition");
  for (  String token : contentDisposition.split(";")) {
    if (token.trim().startsWith("filename")) {
      return token.substring(token.indexOf(‘=‘) + 1).trim().replace("\"","");
    }
  }
  return null;
}

/** 
 * @throws ServletException
 * @throws IOException
 * @throws FileUploadException
 */
public void parseMultiPartRequest() throws ServletException, IOException {
  params=new HashMap<String,Object>();
  for (  Part part : request.getParts()) {
    String filename=getParameterFilename(part);
    String fieldname=part.getName();
    if (filename == null) {
      String fieldvalue=getValue(part);
      params.put(fieldname,fieldvalue);
    }
 else     if (!filename.isEmpty()) {
      if (reachedMaxFileSize(part))       throw new IOException("MAX_FILE_SIZE_REACHED");
      params.put(fieldname,part);
    }
  }
}

/** 
 * @param part
 * @return
 * @throws IOException
 */
public String getValue(Part part) throws IOException {
  BufferedReader reader=new BufferedReader(new InputStreamReader(part.getInputStream(),"UTF-8"));
  StringBuilder value=new StringBuilder();
  char[] buffer=new char[1024];
  for (int length=0; (length=reader.read(buffer)) > 0; ) {
    value.append(buffer,0,length);
  }
  return value.toString();
}

public void doUpload(HttpServletRequest request,HttpServletResponse response) throws IOException, ServletException {
  Collection<Part> parts=request.getParts();
  ArrayList<E> createdObjects=new ArrayList<E>();
  for (  Part part : parts) {
    String fileName=getFileName(part);
    writeFile(part,fileName);
    try {
      createdObjects.add(saveFile(fileName,part));
    }
 catch (    Exception e) {
      throw new ServletException("Can‘t save the file.",e);
    }
  }
  PrintWriter writer=response.getWriter();
  writer.write(new Gson().toJson(createdObjects));
}

/** 
 * Global constructor.
 */
private MultipartMap(HttpServletRequest multipartRequest,String location,boolean multipartConfigured) throws ServletException, IOException {
  multipartRequest.setAttribute(ATTRIBUTE_NAME,this);
  this.encoding=multipartRequest.getCharacterEncoding();
  if (this.encoding == null) {
    multipartRequest.setCharacterEncoding(this.encoding=DEFAULT_ENCODING);
  }
  this.location=location;
  this.multipartConfigured=multipartConfigured;
  for (  Part part : multipartRequest.getParts()) {
    String filename=getFilename(part);
    if (filename == null) {
      processTextPart(part);
    }
 else     if (!filename.isEmpty()) {
      processFilePart(part,filename);
    }
  }
}

/** 
 * Returns the filename from the content-disposition header of the given part.
 */
private String getFilename(Part part){
  for (  String cd : part.getHeader(CONTENT_DISPOSITION).split(";")) {
    if (cd.trim().startsWith(CONTENT_DISPOSITION_FILENAME)) {
      return cd.substring(cd.indexOf(‘=‘) + 1).trim().replace("\"","");
    }
  }
  return null;
}

/** 
 * Process given part as Text part.
 */
private void processTextPart(Part part) throws IOException {
  String name=part.getName();
  String[] values=(String[])super.get(name);
  if (values == null) {
    put(name,new String[]{getValue(part)});
  }
 else {
    int length=values.length;
    String[] newValues=new String[length + 1];
    System.arraycopy(values,0,newValues,0,length);
    newValues[length]=getValue(part);
    put(name,newValues);
  }
}

/** 
 * Process given part as File part which is to be saved in temp dir with the given filename.
 */
private void processFilePart(Part part,String filename) throws IOException {
  filename=filename.substring(filename.lastIndexOf(‘/‘) + 1).substring(filename.lastIndexOf(‘\\‘) + 1);
  String prefix=filename;
  String suffix="";
  if (filename.contains(".")) {
    prefix=filename.substring(0,filename.lastIndexOf(‘.‘));
    suffix=filename.substring(filename.lastIndexOf(‘.‘));
  }
  File file=File.createTempFile(prefix + "_",suffix,new File(location));
  if (multipartConfigured) {
    part.write(file.getName());
  }
 else {
    InputStream input=null;
    OutputStream output=null;
    try {
      input=new BufferedInputStream(part.getInputStream(),DEFAULT_BUFFER_SIZE);
      output=new BufferedOutputStream(new FileOutputStream(file),DEFAULT_BUFFER_SIZE);
      byte[] buffer=new byte[DEFAULT_BUFFER_SIZE];
      for (int length=0; ((length=input.read(buffer)) > 0); ) {
        output.write(buffer,0,length);
      }
    }
  finally {
      if (output != null)       try {
        output.close();
      }
 catch (      IOException logOrIgnore) {
      }
      if (input != null)       try {
        input.close();
      }
 catch (      IOException logOrIgnore) {
      }
    }
  }
  put(part.getName(),file);
  part.delete();
}

@Override protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException {
  final String reqContentType=req.getContentType();
  if (!reqContentType.contains("multipart/form-data")) {
    logger.severe("Received request which is not mulipart: " + reqContentType);
    resp.sendError(406,"Received request which is not mulipart: " + reqContentType);
    return;
  }
  Collection<Part> fileParts=req.getParts();
  if (fileParts != null && fileParts.size() > 0) {
    for (    Part p : fileParts) {
      String partContentType=p.getContentType();
      String partName=p.getName();
      if (partContentType != null && partContentType.equals("text/xml") && partName != null && partName.equals(INPUT_NAME)) {
        InputStream is=p.getInputStream();
        fileUploadBean.parseUpload(is);
        break;
      }
    }
  }
  RequestDispatcher rd=getServletContext().getRequestDispatcher("/");
  if (rd != null) {
    rd.forward(req,resp);
    return;
  }
 else {
    throw new IllegalStateException("Container is not well!");
  }
}

@Override protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException {
  final String reqContentType=req.getContentType();
  if (!reqContentType.contains("multipart/form-data")) {
    logger.severe("Received request which is not mulipart: " + reqContentType);
    resp.sendError(406,"Received request which is not mulipart: " + reqContentType);
    return;
  }
  Collection<Part> fileParts=req.getParts();
  if (fileParts != null && fileParts.size() > 0) {
    for (    Part p : fileParts) {
      String partContentType=p.getContentType();
      String partName=p.getName();
      if (partContentType != null && partContentType.equals("text/xml") && partName != null && partName.equals(INPUT_NAME)) {
        InputStream is=p.getInputStream();
        fileUploadBean.parseUpload(is);
        break;
      }
    }
  }
  RequestDispatcher rd=getServletContext().getRequestDispatcher("/");
  if (rd != null) {
    rd.forward(req,resp);
    return;
  }
 else {
    throw new IllegalStateException("Container is not well!");
  }
}

public void service(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
  PrintWriter out=response.getWriter();
  out.println("<html><head><body>");
  for (  Part part : request.getParts()) {
    String fileName="";
    String partHeader=part.getHeader("content-disposition");
    long partSize=part.getSize();
    out.println("<BR>Part Name = " + part.getName());
    out.println("<BR>Part Header = " + partHeader);
    out.println("<BR>Part Size = " + partSize);
    System.out.println("part.getHeader(\"content-disposition\") = " + part.getHeader("content-disposition"));
  }
  out.println("<center><h1>File Upload Completed Successfully</h1></center></body></html>");
  System.out.println("Custom Way To Upload File with Actual FileName.");
  fileUploadWithDesiredFilePathAndName(request);
  System.out.println("File Uploaded using custom Way.");
}

/** 
 * Create a new StandardMultipartHttpServletRequest wrapper for the given request.
 * @param request the servlet request to wrap
 * @throws MultipartException if parsing failed
 */
public StandardMultipartHttpServletRequest(HttpServletRequest request) throws MultipartException {
  super(request);
  try {
    Collection<Part> parts=request.getParts();
    MultiValueMap<String,MultipartFile> files=new LinkedMultiValueMap<String,MultipartFile>(parts.size());
    for (    Part part : parts) {
      String filename=extractFilename(part.getHeader(CONTENT_DISPOSITION));
      if (filename != null) {
        files.add(part.getName(),new StandardMultipartFile(part,filename));
      }
    }
    setMultipartFiles(files);
  }
 catch (  Exception ex) {
    throw new MultipartException("Could not parse multipart servlet request",ex);
  }
}

public void cleanupMultipart(MultipartHttpServletRequest request){
  try {
    for (    Part part : request.getParts()) {
      if (request.getFile(part.getName()) != null) {
        part.delete();
      }
    }
  }
 catch (  Exception ex) {
    LogFactory.getLog(getClass()).warn("Failed to perform cleanup of multipart items",ex);
  }
}