come caricare un file utilizzando il flusso di file comuni streaming api

Question

Sto seguendo l'esempio fornito nel sito di caricamento di file comuni su API di streaming. Sono bloccato cercando di capire come ottenere l'estensione del file caricato, come scrivere il file in una directory e la parte peggiore è dove la persona che ha scritto l'esempio commenta // Process the input stream... Mi chiedo se sia qualcosa di così banale che Sono l'unico che non sa come.

Answer 1

Utilizzare questo nel file HTML:

<form action="UploadController" enctype="multipart/form-data" method="post"> 
    <input type="file"> 
</form> 

e nel UploadController servlet, all'interno del metodo doPost:

boolean isMultipart = ServletFileUpload.isMultipartContent(request); 

    if (isMultipart) { 
     FileItemFactory factory = new DiskFileItemFactory(); 
     ServletFileUpload upload = new ServletFileUpload(factory); 

    try { 
     List items = upload.parseRequest(request); 
     Iterator iterator = items.iterator(); 
     while (iterator.hasNext()) { 
      FileItem item = (FileItem) iterator.next(); 

      if (!item.isFormField()) { 
       String fileName = item.getName(); 

       String root = getServletContext().getRealPath("/"); 
       File path = new File(root + "/uploads"); 
       if (!path.exists()) { 
        boolean status = path.mkdirs(); 
       } 

       File uploadedFile = new File(path + "/" + fileName); 
       System.out.println(uploadedFile.getAbsolutePath()); 
       item.write(uploadedFile); 
      } 
     } 
    } catch (FileUploadException e) { 
     e.printStackTrace(); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
} 

Answer 2

Ecco una servlet che fa quello che si vuole fare.

package rick; 
import javax.servlet.*; 
import javax.servlet.http.*; 
import java.io.*; 
import org.apache.commons.fileupload.*; 
import org.apache.commons.fileupload.util.*; 
import org.apache.commons.fileupload.servlet.ServletFileUpload; 
import javax.servlet.annotation.WebServlet; 
@WebServlet("/upload4") 
public class UploadServlet4 extends HttpServlet{ 
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
     throws ServletException, IOException { 
     PrintWriter out = response.getWriter(); 
     out.print("Request content length is " + request.getContentLength() + "<br/>"); 
     out.print("Request content type is " + request.getHeader("Content-Type") + "<br/>"); 
     boolean isMultipart = ServletFileUpload.isMultipartContent(request); 
     if(isMultipart){ 
        ServletFileUpload upload = new ServletFileUpload(); 
      try{ 
       FileItemIterator iter = upload.getItemIterator(request); 
       FileItemStream item = null; 
       String name = ""; 
       InputStream stream = null; 
       while (iter.hasNext()){ 
            item = iter.next(); 
            name = item.getFieldName(); 
            stream = item.openStream(); 
        if(item.isFormField()){out.write("Form field " + name + ": " 
              + Streams.asString(stream) + "<br/>");} 
        else { 
         name = item.getName(); 
         System.out.println("name==" + name); 
         if(name != null && !"".equals(name)){ 
         String fileName = new File(item.getName()).getName(); 
         out.write("Client file: " + item.getName() + " <br/>with file name " 
                + fileName + " was uploaded.<br/>"); 
         File file = new File(getServletContext().getRealPath("/" + fileName)); 
         FileOutputStream fos = new FileOutputStream(file); 
         long fileSize = Streams.copy(stream, fos, true); 
         out.write("Size was " + fileSize + " bytes <br/>"); 
         out.write("File Path is " + file.getPath() + "<br/>"); 
         } 
        } 
       } 
      } catch(FileUploadException fue) {out.write("fue!!!!!!!!!");} 
     } 
    } 
} 

Answer 3

C'è una fantastica "biblioteca" per fare questo per voi. In realtà è solo un esempio di codice di un filtro che intercetterà tutti i messaggi di tipo multiparte e ti darà accesso al file, al nome del file ecc ... che puoi gestire nel normale metodo del servlet post.

http://balusc.blogspot.com/2007/11/multipartfilter.html

Answer 4

Il problema di tutte queste risposte è che non risponde alla domanda originale !!

Come dice "elaborare il flusso di input" in realtà ti confonde cosa fare dopo. Stavo guardando questa domanda tutta la notte scorsa cercando di trovare un suggerimento da una delle risposte, ma niente. Sono andato a provare altri siti e niente.

Il fatto è che ciò che stiamo facendo è fuori dall'ambito di caricamento del file, e questo è il problema.

Ora stiamo lavorando con Java.IO InputStream

InputStream stream = item.openStream(); 

ora lavoriamo con quel "flusso".

https://www.google.com/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=+writing+a+java+inputstream+to+a+file

Qui si possono trovare tutti i tipi di risposte a quello che vi serve. È piuttosto sciocco che sia così vago, e sembra che tu debba fare qualcosa in più con i Commons, ma in realtà non è un bene comune. InputStream è Java.io!

Nel nostro caso prendiamo il torrente c'è dato e carichiamo in un nuovo file con la lettura di dati byte

Questo sito ha anche una serie di opzioni che potrebbero essere utili http://www.jedi.be/blog/2009/04/10/java-servlets-and-large-large-file-uploads-enter-apache-fileupload/

Spero che questo aiuta gli altri chi è confuso e nuovo a FileUploading, perché ho appena capito questo alcuni minuti prima di scrivere questa risposta.

Ecco il mio codice che salva un file nell'unità principale.

try { 
      System.out.println("sdfk"); 

      boolean isMultipart = ServletFileUpload.isMultipartContent(request); 


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

// Parse the request 
      FileItemIterator iter = upload.getItemIterator(request); 


      while (iter.hasNext()) 
      { 
       FileItemStream item = iter.next(); 
       String name = item.getFieldName(); 
       InputStream stream = item.openStream(); 


        System.out.println("File field " + name + " with file name " 
          + item.getName() + " detected."); 
        // Process the input stream 
        File f = new File("/"+item.getName()); 

       System.out.println(f.getAbsolutePath()); 

       FileOutputStream fout= new FileOutputStream(f); 
       BufferedOutputStream bout= new BufferedOutputStream (fout); 
       BufferedInputStream bin= new BufferedInputStream(stream); 


       int byte_; 

       while ((byte_=bin.read()) != -1) 
       { 
        bout.write(byte_); 
       } 

       bout.close(); 
       bin.close(); 


      }  

     } 
     catch (FileUploadException ex) 
     { 
      Logger.getLogger(UploadServlet.class.getName()).log(Level.SEVERE, null, ex); 
     } 
     response.sendRedirect("/plans.jsp"); 

Buona fortuna!

Answer 5

Ho dato qui http://www.javamonamour.org/2015/10/web-application-for-file-upload-with.html un esempio operativo completo (un progetto Eclipse per WebLogic, ma è possibile adattarlo facilmente a Tomcat).

Altrimenti git clone solo https://github.com/vernetto/WebFileUploaderStreaming. Un esempio di lavoro completo è migliore di un migliaio di frammenti di codice.