Javaweb -Datei -Hochladen und Download -Funktionsanalyse

Das Hochladen und Herunterladen von Dateien ist während der Entwicklung sehr häufig. Hier ist eine kurze Zusammenfassung:

1. Bedingungen, die für den Datei -Upload erfüllt sein müssen:
A. Die Methode des Seitenformulars muss postiert werden, da die durch GET übertragenen Daten zu klein sind
B. Der EncTePe des Seitenformulars muss aus mehrteiler/Formdaten-Typ sein
C. Das Formular enthält Details zum Hochladen von Eingabefeld Code: Im Client-Formular: <Formular engType = "MultiPart/Form-Data"/>
(Wenn diese Eigenschaft nicht verfügbar ist, variiert der vom Server gelesene Dateipfad je nach Browser ab.)
Server ServletInputStream ist = request.getInputStream (); Erhält den Anforderungskörpergehalt in einem Stream zur weiteren Analyse.

2. Details zum Hochladen von Dateien:
(1) Warum den Formulartyp einstellen auf: Mehrart/Formdaten. Es soll den von diesem Formular übergebenen Wert festlegen, der nicht der Schlüssel = Wert ist. Was übergeben wird, ist Bytecode.
Die Korrespondenz zwischen der Form und der Anfrage:

Wie oben gezeigt, können Sie feststellen, dass nach dem Einstellen des Formulartyps auf: MultiPart/Form-Data die von Ihnen ausgewählte Datei in der HTTP-Anforderungsbehörde in Binary initialisiert wird, wie im obigen Bild unter einer zufälligen Zeichenfolge unter dem Cookie gezeigt.
Beachten Sie jedoch, dass es in der Datei -Bytecode zwei spezielle Zeichenzeilen von Zeichen gibt, geteilt durch die Identifikationsdatei (d. H. Eine Zeichenfolge von zufälligen Zeichenfolgen), nämlich die erste Zeile des Inhaltsdatei -Headers und eine Linie von leeren Zeilen. Die dritte Zeile danach ist der Binärdateiinhalt.
Wenn der Server die vom Client hochgeladenen Dateien akzeptiert, müssen die ersten drei Zeilen entfernt werden, wenn die Datei Binärer in den HTTP -Anforderungsparametern erhalten wird.

3.. Analysieren Sie die hochgeladene TXT -Datei manuell:

 Import Java.io.BuffenedReader; Import Java.io.ioxception; Import Java.io.inputStream; Import Java.io.inputStreamReader; Import Java.io.printwriter import Javax.servlet.ServletException; Import Javax.servlet.http.http.http.http.htp. javax.servlet.http.httpServletRequest; importieren javax.servlet.http.httpServletResponse;/** * Wenn der Typ eines Formulars post ist und der Enctype im Binärmodus an dem Server an den Server übergeben wird. * Also ist Req.getParameter ("xxx") immer null. * Sie können nur Daten über req.getInputStream () abrufen und die Daten des Textes abrufen String txt = req.getParameter ("txt"); // Die Rückgabe ist null system.err.println ("txt ist:"+txt); System.err.println ("======================================="); InputStream in = req.getInputStream (); // byte [] b = new Byte [1024]; // int len ​​= 0; // while ((len = in.read (b))! InputStreamReader (in)); String Firstline = Br.readline (); // Lesen Sie die erste Zeile, und die erste Zeile ist ein abgelehntes Symbol, dh ein zufälliger String -String -Dateiname = Br.Readline (); // Die zweite Zeile von Dateiinformationen und den Dateinamen von IT FileName = Dateiname.substring (FileName.LastExof ("///")+1; 1; fileName.substring (0, Dateiname.Length ()-1); while (Data = Br.Readline ()!

4. Verwenden Sie Apache-fileUpload, um Dateien-Uploads zu verarbeiten:
Framework: Bezieht sich auf die Einkapselung des Unternehmens, das Benutzer häufig in einem Code verarbeiten. Machen Sie es den Benutzern leicht, anzurufen.
Die (Frame) -Komponente, die derzeit die Datei hochladen:
Apache-Fileeupload-
Orialiy cos 2008 () -
JSP-Smart-Upload 200 m.
Laden Sie die Datei mit FileUpload hoch:

Erfordert das Importieren von Paketen von Drittanbietern:

Apache-fileUpload.jar-Datei lädt das Kernpaket hoch.
Apache-commons-io.jar Dieses Paket ist ein Abhängigkeitspaket für FileUpload. Es ist auch ein Toolkit.

Kernkategorie:

DiskFileItemFactory legt Speicherplatz fest und speichert temporäre Dateien. Nur eine Klasse.
ServletFileUpload - Die Kernklasse für Datei -Uploads, die Anfragen und Parse -Requitionen empfängt.
ServletFileUpload.ParSerequest (Requedest) - List <Dateinitem>
Hinweis: Ein FileItem ist der Beginn eines Logos: -------- 243243242342 TO --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Schritt 1: Importieren Sie das Paket:

Schritt 2: Schreiben Sie ein Servlet, um die Dopost -Methode zu vervollständigen

 /*** Zwei von diskfileItemfactory konstruierte Parameter* Der erste Parameter: SizeThreadhold - Legt fest, wie viele Daten Bytes von Daten im Cache (Speicher) speichern können. Die Standardeinstellung ist 10k* Wenn eine Datei nicht mehr als 10K ist, können Sie ihn einfach in eine Datei speichern. * Wenn eine Datei größer als 10 km ist, müssen Sie die Datei zuerst in einem temporären Verzeichnis speichern. * Die zweite Parameterdatei bezieht sich auf den temporären Verzeichnisort * * */public class UP2Servlet erweitert HttpServlet {public void dopost (httpServletRequest req, httpServletResponse resp). // Erhalten Sie den Pfad des Projekts String path = getServletContext (). GetRealPath ("/up"); // Der erste Schritt deklariert die DiskFileItemFactory Factory -Klasse, mit der ein temporäres Verzeichnis auf der Festplatte festgelegt wird. // Der zweite Schritt: Deklare ServletFileUpoload und empfangen Sie das obige temporäre Verzeichnis. // Der dritte Schritt: Analyse Anfragen try {list <FileItem> list = up.parsequest (req); // Wenn nur eine Datei -FileItem -Datei = list.get (0); // den Dateinamen mit Pfad string Dateiname = Datei.getName () abrufen; Dateiname = Dateiname.substring (Dateiname.lastIndexof ("//")+1); // den Dateityp String fileType = file.getContentType () abrufen; // Erhalten Sie den ByteCode InputStream der Datei in = file.getInputStream (); // Deklarieren Sie den Ausgabebyte Stream OutputStream out = new FileOutputStream (Pfad+"/"+Dateiname); // Datei kopieren byte [] b = neues byte [1024]; int len ​​= 0; while ((len = in.read (b))! =-1) {out.write (b, 0, len); } out.close (); Long Size = Datei.GetInputStream (). AFFORMT (); // die hochgeladene temporäre Dateidatei löschen.Delete (); // Daten resp.setContentType anzeigen ("text/html; charSet = utf-8"); Printwriter op = resp.getWriter (); op.print ("Datei erfolgreich hochgeladen <br/> Dateiname:"+Dateiname); op.print ("<br/> Dateityp:"+Filetype); op.print ("<br/> Dateigröße (Bytes)"+Größe); } catch (Ausnahme e) {e.printstacktrace (); }}}

5. Verwenden Sie dieses Framework, um mehrere Dateien hochzuladen:

Schritt 1: Ändern Sie die Form der Seite in mehreren Eingabetypen = "Datei".

 <form action = "<c: url value = '/up3Servlet' //>" method = "post" engType = "multiPart/form-data"> file1: <input type = "file" name = "txt"> <br/> Datei2: <Eingabe type = "Datei" name = "txt"> <br/> <Eingabe-Typ = "Subjekt"/> </> </> </> </> </> </> </</</</Form>

Schritt 2: Traverse -Liste

 public class up3Servlet erweitert HttpServlet (public void dopost (httpServletRequest Request, httpServletResponse-Antwort). String path = getServletContext (). GetRealPath ("/up"); // diskfileItemfactory disk = new diskFileItemfactory () deklarieren; disk.SetSizethreshold (1024*1024); disk.setRepository (neue Datei ("d:/a")); // Deklariere den Servlet, der die Anforderung analysiert, servletFileUpload up = new servletFileUpload (Festplatte); Versuchen Sie {// Anforderungsliste <DileItem> list = up.parsequest (request); // eine Liste <Map> deklarieren Sie die Daten der hochgeladenen Dateiliste <map <String, String >> ups = new ArrayList <map <String, String >> (); für (FileItem -Datei: List) {Map <String, String> mm = new HashMap <String, String> (); // den Dateinamen String -String Dateiname = Datei.getName () abrufen; Dateiname = Dateiname.substring (Dateiname.lastIndexof ("//")+1); String fileType = file.getContentType (); InputStream in = file.getInputStream (); int size = in.Available (); // Verwenden Sie die Tool Class -Dateiutils.copyInputStreamToFile (in neue Datei (Pfad+"/"+Dateiname)); mm.put ("Dateiname", Dateiname); mm.put ("Filetyp", Filetype); mm.put ("size", "+size); ups.add (mm); Datei.delete ();} request.setAttribute (" ups ", ups); // Vorwärtsanforderung.

Das obige ist die gemeinsame Methode zum Hochladen von Dateien. Schauen wir uns nun die anderen Such -APIs von FileUpload an.

Bestimmen Sie, ob ein FileItem ein Objekt (Type = Datei) oder ein Text (Type = Text | Kontrollkästchen | Radio) ist: Objekt:
boolean isFormfield () Wenn es sich um ein text | Kontrollkästchen | Radio | auswählen, ist der Wert wahr.

6. Bilder mit Beschreibungsinformationen verarbeiten

 Die öffentliche Klasse updescServlet erweitert HttpServlet (public void dopost (httpServletRequest), HttpServletResponse-Antwort aus, IOException {request.setcharactercoding ("utf-8"); // Sie können den chinesischen Dateinamen Sting-Patha-Namen erhalten. DiskFileItemFactory disk = new diskFileItemFactory (); disk.setRepository (neue Datei ("d:/a")); Versuchen Sie {servletFileUpload up = new ServletFileUpload (Festplatte); List <FileItem> list = up.ParSequest (Anfrage); for(FileItem file:list){ //Step 1: Determine whether it is an ordinary form item if(file.isFormField()){ String fileName = file.getFieldName();//<input type="text" name="desc">=desc String value = file.getString("UTF-8");//By default, read data in ISO, System.err.println(fileName+"="+value); } else {// zeigt an, dass es sich um eine Datei string fileName = file.getName () handelt; Dateiname = Dateiname.substring (Dateiname.lastIndexof ("//")+1); Datei.Write (neue Datei (Pfad+"/"+Dateiname)); System.err.println ("Dateiname ist:"+Dateiname); System.err.println ("Dateigröße ist:"+file.getSize ()); Datei.delete (); }}} catch (exception e) {e.printstacktrace (); }}}

7. Verbesserte Leistung des Datei -Uploads
Verwenden Sie bei der Anfrage zur Erhöhung der DateiItem -Sammlung:

FileItemiterator it = up.getItemiterator (Anfrage);

Im Vergleich zum Gebrauch

List <FileItem> list = up.ParSequest (Anfrage);

Viel bessere Leistung.
Beispielcode:

 Öffentliche Klasse FastServlet erweitert HttpServlet (public void dopost (httpServletRequest Request, httpServletResponse-Antwort), die ServletException, IOException {request.setcharactercoding ("utf-8"); String path = getServletContext (). GetRealPath ("/up"); DiskFileItemFactory disk = new diskFileItemFactory (); disk.setRepository (neue Datei ("d:/a")); Versuchen Sie {servletFileUpload up = new ServletFileUpload (Festplatte); // Folgendes ist der Iterator -Modus -FileItemiterator it = up.getItemiterator (Anfrage); while (it.hasnext ()) {FileItemStream item = it.next (); String Dateiname = item.getName (); Dateiname = Dateiname.substring (Dateiname.lastIndexof ("//")+1); InputStream in = item.openStream (); FileUtils.copyInputStreAmtOFile (in, neue Datei (Pfad+"/"+Dateiname)); }} catch (Ausnahme e) {e.printstacktrace (); }}}

8. Datei herunterladen
Es kann entweder bekommen oder posten.

 public void dopost (httpServletRequest req, httpServletResponse resp) löst ServletException aus, ioException {req.setcharactercoding ("utf-8"); String name = req.getParameter ("Name"); // Schritt 1: Setzen Sie den Antworttyp resp.setContentType ("Anwendung/Kraftdownload"); // Die zweite Lesedatei String path = getServletContext (). GetRealPath ("/up/"+name); InputStream in = neuer FileInputStream (Pfad); // Setzen Sie den Antwortheader // URL-URL-Codierung des Dateinamens Name = urlencoder.encode (Name, "UTF-8"); resp.setheader ("Inhaltsdisposition", "Anhang; Dateiname ="+Name); resp.setContentLength (in.Available ()); // Schritt 3: Starten Sie die Dateikopie outputStream out = resp.getOutputStream (); Byte [] B = neues Byte [1024]; int len ​​= 0; while ((len = in.read (b))! =-1) {out.write (b, 0, len); } out.close (); in.close (); } Bei Verwendung von J2EE Popular Framework

Es ist einfacher, die interne Kapselung des Frameworks zu verwenden, um Upload und Download zu vervollständigen:

Struts2 wird hochgeladen.

Bei der Verwendung von Struts2 für die Entwicklung ist es nicht schwer zu ermitteln, dass das Paket commons-fileUpload-1.3.1.Jar im importierten JAR-Paket vorhanden ist. Durch das obige Lernen können wir es bereits zum Hochladen und Herunterladen von Dateien verwenden. Aber Struts2 wird eine weitere Verkapselung unterzogen.

Sicht

 <form action="fileUpload.action" method="post" enctype="multipart/form-data"> username: <input type="text" name="username"><br> file: <input type="file" name="file"><br> <input type="submit" value="submit"> </form>

Regler

 öffentliche KlassendateiEUploadAction erweitert actionupport {private String -Benutzername; // Beachten Sie, dass die Datei nicht auf die von der Front-End JSP hochgeladene Datei selbst verweist, sondern die Datei, die in die Datei der privaten Dateidatei unter dem temporären Ordner gespeichert wurde, hochgeladen wurde. // Der Name der eingereichten Datei // Struts fangen automatisch den Namen der letzten Datei ab und injizieren sie in diese Eigenschaft private String -Dateifilmame. // Getter und Setzer werden zu diesem Zeitpunkt gespeichert, um space @Override public String execute () auszusetzen {// Speichern Sie den Pfad zum hochgeladenen Datei -String root = servletActionContext.getServletContext (). GetRealPath ("/Upload"); // Temporäre Dateieingabestream inputStream abrufen ist = new FileInputStream (Datei); // Ausgabedatei Ausgabestream OS = New FileOutputStream (neue Datei (Root, FileFileName)); // den Dateinamen des hochgeladenen Dateisystems ausdrucken. // Da Datei eine Datei ist, die in einem temporären Ordner gespeichert ist, können wir den Dateinamen und den Dateipfad ausdrucken, um festzustellen, ob sie mit dem vorherigen FileFileName System.out.println ("Datei:" + Datei.getName ()) übereinstimmen. System.out.println ("Datei:" + file.getPath ()); byte [] buffer = neues byte [1024]; int länge = 0; while (-1! } os.close (); IS.CLOSE (); Erfolgserfolg; }}

Zunächst müssen wir klarstellen, dass sich die Datei hier nicht wirklich auf die von JSP hochgeladene Datei bezieht. Wenn die Datei hochgeladen wird, sucht Struts2 zunächst nach dem von Struts.multiPart.Savedir angegebenen Speicherort (dies befindet sich in Standard. Properties) (Standard ist leer). Wir können diesen temporären Speicherort in Struts2 unseres Projekts angeben.

<Constant name = "stolzs.multipart.savedir" value = "/repository"/>

Wenn Struts.multipart.Savedir nicht festgelegt ist, wird die von javax.servlet.context.tempdir angegebene Adresse standardmäßig verwendet. Der Wert von javax.servlet.context.tempdir wird vom Server bestimmt. Zum Beispiel: Wenn der Kontext meines Webprojekts ABC ist und der Server Tomcat verwendet, sollte SavePath %Tomcat_Home %/Work/Catalina/localhost/ABC_ sein. Der Name der temporären Datei ähnelt dem Upload__1A156008_1373A8615DD__8000_00000001.tmp. Der temporäre Dateiname kann jedes Mal unterschiedlich sein, ist jedoch ungefähr in diesem Stil. Und wenn Sie Server in Eclipse verwenden, um Tomcat zu konfigurieren und zu starten, ist das % tomcat_home % in der obigen Adresse nicht das tatsächliche Tomcat -Root -Verzeichnis im System, sondern die von Eclipse angegebene Adresse. Zum Beispiel lautet meine lokale Adresse wie folgt: /home/wang/eclipsejavacode/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/work/catalina/LocalHost

Struts2 ist fertig heruntergeladen.

Laden Sie die Struts2 -Datei einfacher herunter, definieren Sie einfach einen Eingabestream und schreiben Sie die Datei in den Eingabestream. Die Schlüsselkonfiguration besteht weiterhin darin, sie in der Konfigurationsdatei von Strebens.xml zu konfigurieren:

 Die öffentliche Klassen fileDownloadAction erweitert ActionVerform {// den Pfad zum Herunterladen der Datei auf dem server privaten String -Pfad; // den Dateinamen der Datei zum Herunterladen privater String -DownloadFileName; // Schreiben Sie Getter und Setter public InputStream getDownloadFile () {return servletActionContext.getServletContext (). GetResourceAsStream (Pfad); } @Override public String execute () löst Ausnahme aus {// Die aktuelle Aktion ist setdownloadFileName (xxx); Erfolgserfolg; }}

Die Aktion definiert nur eine Eingabestream -DownloadFile und bietet sie dann eine Getter -Methode. Schauen wir uns als Nächstes die Konfigurationsdatei von Struts.xml an:

 <Action name = "apledownload"> <result name = "download" type = "stream"> <param name = "contentDisposition"> Anhang; fileName = "$ {downloadFileName}" </param> <param name = "inputName"> downloadFile </param> </result> </action> </action> </action>

Es gibt mehrere Orte, an denen wir auf die Konfigurationsdatei von Struts.xml achten müssen. Zunächst muss der Typ als Stream type_ definiert werden, und die Aktion, dies ist das Ergebnis des Datei -Downloads. Das Ergebniselement hat im Allgemeinen einen Param-Unterelement. Dies wird verwendet, um die Parameter beim Herunterladen der Datei einzustellen. Das Attribut "InputName" soll den Dateieingabestream in der Aktion erhalten. Der Name muss dem Eingabestream -Attribut in der Aktion übereinstimmen. Dann das ContentDisposition -Attribut. Dieses Attribut wird im Allgemeinen verwendet, um anzugeben, wie wir die heruntergeladene Datei verarbeiten möchten. Wenn der Wert der Anhang ist, wird ein Download -Box angezeigt, sodass der Benutzer auswählen kann, ob heruntergeladen werden soll. Wenn dieser Wert nicht festgelegt ist, prüft der Browser zunächst, ob die heruntergeladene Datei geöffnet werden soll. Wenn dies möglich ist, öffnet es direkt die heruntergeladene Datei (natürlich ist es nicht das, was wir brauchen). Ein weiterer Wert ist der Dateiname, der den von der Datei beim Herunterladen aufgeführten Datei -Download -Namen ist. Nach dem Konfigurieren dieser Informationen können wir die Funktion "Datei Download" implementieren.

SpringMVC vervollständigt Upload:

Die Ansicht entspricht genau dem Beispiel für Struts2. Dies ist nicht geschrieben.

Regler:

 @Controller@RequestMapping (value = "Fileoperate") public class FileoperateAction {@RequestMapPing (value = "Upload") öffentlicher String -Upload (httpServletRequest -Anforderung,@RequestParam ("Datei") MultiPartFile Photofile) {// Der Pfad zum Upload -Datei Save -Datei Save String DIR = String Dir = Streich. Request.GetSession (). getServletContext (). getRealPath ("/")+"Upload"; // Der Original -Dateiname Zeichenfolge String Dateiname = PhotOFile.getOriginalFileName (); // Die Dateierweiterungszeichenfolge extname = fileName.substring (Dateiname.lastIndexof (".")) Abrufen; // Dateinamen Konflikte verhindern, den Namen fileName = Dateiname.substring (0, fileName.lastindexof ("."))) + System.nanotime () + extname geringfügig ändern. FileUtils.writebytearrayToFile (neue Datei (Dir, Dateiname), PhotOFile.getBytes ()); zurück "Erfolg"; }}

SpringMVC Complete Download:

 @RequestMapping ("/download") public string download (String-Dateiname, httpServletRequest-Anforderung, httpServletResponse-Antwort) {response.setcharactercoding ("utf-8"); response.setContentType ("Multipart/Form-Data"); response.setheader ("Inhaltsdisposition", "Anhang; Dateiname =" + Dateiname); Try {InputStream InputStream = new FileInputStream (neue Datei (Pfad der Datei); OutputStream os = Antwort } catchfoundException e) {E.PrintStacktrace ();

Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.