Datei Upload und Download mit Servlet

Question

Ich möchte ein einfaches Java-Servlet schreiben, das Datei-Upload von einer einfachen HTML-Seite empfängt, tut etwas mit der Datei und sendet die manipulierte Datei an den Benutzer zurück.

Das Dateiupload-Ereignis wird von der doPost-Methode eines Servlets auf der Serverseite behandelt. Die Anforderung ist, dass das Fenster "Speichern unter ..." sofort nach dem Hochladen und Verarbeiten der Datei auf der Serverseite angezeigt werden muss und der Benutzer die generierte Datei auf seinem Computer speichern kann.

Datei-Upload wird von doPost behandelt und Datei-Download wird von der Methode doGet eines Servlets behandelt. Ist es möglich, diese beiden Ereignisse irgendwie miteinander zu verbinden?

Kann ich Byte-Inhalt als Antwort auf ein Dateiupload-Ereignis empfangen? Ich lade Datei mit Ajax-Post und ich kann Inhalt an den Browser zurücksenden, und ich kann diese Nachricht auf der Clientseite anzeigen.

Ist es möglich, einen cleveren Java-Skriptcode zu schreiben, der binäre Inhalte als Antwort einer Postanforderung empfängt und den Webbrowser zwingt, das Fenster "Speichern unter ..." zum Speichern der empfangenen Bytes in einer Datei aufzurufen ?

könnte andere Lösung

1. Datei-Upload mit Ajax
2. auf der Serverseite wird der neu generierten Inhalt in eine Datei in ein temporäres Verzeichnis auf dem Server
3. id oder den Pfad der Datei gespeichert wird wird als Antwort an den Client zurückgeschickt
4. Client (Java-Skript) empfängt die ID der generierten Datei und führt sofort eine neue GET-Anforderung an ein Datei-Download-Servlet
5. Datei herunterladen servlet empfängt die ID/den Pfad der Datei und liest sie aus dem Ordner temp und sendet i bact an den Webbrowser des Clients.

Was ist die beste Vorgehensweise für dieses Szenario?

Answer 1

import gwtupload.server.UploadAction; 
import gwtupload.server.exceptions.UploadActionException; 

import org.apache.commons.fileupload.FileItem; 

import java.io.File; 
import java.io.FileInputStream; 
import java.io.IOException; 
import java.util.Hashtable; 
import java.util.List; 

import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 




/** 
* This is an example of how to use UploadAction class. 
* 
* This servlet saves all received files in a temporary folder, 
* and deletes them when the user sends a remove request. 
* 
* @author Manolo Carrasco Moñino 
* 
*/ 
public class SampleUploadServlet extends UploadAction { 

    private static final long serialVersionUID = 1L; 

    Hashtable<String, String> receivedContentTypes = new Hashtable<String, String>(); 
    /** 
    * Maintain a list with received files and their content types. 
    */ 
    Hashtable<String, File> receivedFiles = new Hashtable<String, File>(); 

    /** 
    * Override executeAction to save the received files in a custom place 
    * and delete this items from session. 
    */ 
    @Override 
    public String executeAction(HttpServletRequest request, List<FileItem> sessionFiles) throws UploadActionException { 
    String response = ""; 
    int cont = 0; 
    for (FileItem item : sessionFiles) { 
     if (false == item.isFormField()) { 
     cont++; 
     try { 
      /// Create a new file based on the remote file name in the client 
      // String saveName = item.getName().replaceAll("[\\\\/><\\|\\s\"'{}()\\[\\]]+", "_"); 
      // File file =new File("/tmp/" + saveName); 

      /// Create a temporary file placed in /tmp (only works in unix) 
      // File file = File.createTempFile("upload-", ".bin", new File("/tmp")); 

      /// Create a temporary file placed in the default system temp folder 
      File file = File.createTempFile("upload-", ".bin"); 
      item.write(file); 

      /// Save a list with the received files 
      receivedFiles.put(item.getFieldName(), file); 
      receivedContentTypes.put(item.getFieldName(), item.getContentType()); 

      /// Compose a xml message with the full file information 
      response += "<file-" + cont + "-field>" + item.getFieldName() + "</file-" + cont + "-field>\n"; 
      response += "<file-" + cont + "-name>" + item.getName() + "</file-" + cont + "-name>\n"; 
      response += "<file-" + cont + "-size>" + item.getSize() + "</file-" + cont + "-size>\n"; 
      response += "<file-" + cont + "-type>" + item.getContentType() + "</file-" + cont + "type>\n"; 
     } 
     catch (Exception e) 
     { 
     } 
     } 
    } 

    /// Remove files from session because we have a copy of them 
    removeSessionFileItems(request); 

    /// Send information of the received files to the client. 
    return "<response>\n" + response + "</response>\n"; 
    } 

    /** 
    * Get the content of an uploaded file. 
    */ 
    @Override 
    public void getUploadedFile(HttpServletRequest request, HttpServletResponse response) throws IOException { 
    String fieldName = request.getParameter(PARAM_SHOW); 
    File f = receivedFiles.get(fieldName); 
    if (f != null) { 
     response.setContentType(receivedContentTypes.get(fieldName)); 
     FileInputStream is = new FileInputStream(f); 
     copyFromInputStreamToOutputStream(is, response.getOutputStream()); 
    } else { 
     renderXmlResponse(request, response, ERROR_ITEM_NOT_FOUND); 
    } 
    } 

    /** 
    * Remove a file when the user sends a delete request. 
    */ 
    @Override 
    public void removeItem(HttpServletRequest request, String fieldName) throws UploadActionException { 
    File file = receivedFiles.get(fieldName); 
    receivedFiles.remove(fieldName); 
    receivedContentTypes.remove(fieldName); 
    if (file != null) { 
     file.delete(); 
    } 
    } 

} 

Code zum Hochladen der Dateien auf dem Server.