Récemment, le projet doit être téléchargé un fichier. Après avoir terminé les travaux, partagez-le et prenez également des notes.
La fonction de téléchargement est implémentée en arrière-plan et Java, et le frontal est principalement implémenté dans AJAX de JS. L'arrière-plan ajoute également des fichiers temporaires à supprimer régulièrement.
L'effet est comme indiqué dans l'image
Tout d'abord, la classe principale de la fonction de téléchargement, ce qui suit est le code
package util.upload; importer java.io.file; import java.io.ioexception; import java.text.simpledateformat; import java.util.date; import java.util.itreator; import java.util.list; javax.servlet.http.httpservlet; import javax.servlet.http.httpservletRequest; Importer javax.servlet.http.httpSession; org.apache.commons.fileupload.disk.diskfileItemfactory; import org.apache.commons.fileupload.servlet.servletFileupload; classe publique UploadServlet étend httpservlet {private static final SerialVeeSionuid = -3100028422371321159l; Boolean privé Isallowed; String privé upFileName; // Définir le tableau avec un nom de suffixe juridique String privé [] alloweDextName = new String [] {"zip", "rar", // Fichier de compression "txt", "doc", "wps", "docx", "java", // text "xls", "xlsx", // table "ppt", "pptx", // diapositive "pdf", // play "f" jpg "," bmp "," gif "," png "// image}; protected Void doget (hTTSerSerre HttpServletResponse Réponse) lève Servlexception, ioException {doPost (request, réponse);} protected void doPost (httpservletRequest, httpServletResponse Réponse) lance Servlexception, ioException {// Définit le format d'encodage vers UTF-8 demande.secharactera Response.SetcharActerending (UTF-8 "); // Définissez une valeur maximale pour le fichier téléchargé, qui ne doit pas dépasser 100MB int maxsize = 100 * 1024 * 1024; ServletFileUpload upload = new ServletFileUpload (Factory); // Créer un écouteur de téléchargement et définir l'écouteur UploadListener écouteur = nouveau uploadListener (); session.setAttribute ("écouteur", auditeur); upload.setProgressListener (écouteur); // Téléchargez le chemin de la chaîne Path = request.getSession (). GetServletContext (). GetRealPath ("/ upload"); String requestPath = request.getSession (). GetServletContext (). GetContextPath () + "/ upload"; Fichier dirfile = nouveau fichier (chemin); //System.out.println(Request.getSession (). GetServletContext (). GetContextPath ()); // Si le dossier n'existe pas, créez si (! Dirfile .exists () &&! Dirfile .isDirectory ()) {dirfile .mkdir (); } // Créez un dossier basé sur la date et enregistrez-le dans le dossier avec la date de date correspondante = new Date (); SimpledateFormat sdf = new SimpledateFormat ("yyyymmdd"); String subDirName = sdf.format (date); File subdirfile = new File (path + "/" + subdirname); if (! subdirfile .exists () &&! subdirfile .isDirectory ()) {subdirfile .mkdir (); } essayez {// l'analyse de requête de téléchargement de la liste <fichierItem> items = upload.parseRequest (request); Iterator <FichierItem> iTr = items.Itator (); while (ir.hasnext ()) {fileItem item = (fileItem) itr.next (); // Déterminez s'il s'agit d'un domaine de fichier if (! Item.isformField ()) {if (item.getName ()! = Null &&! Item.getName (). Equals ("")) {// Obtenez la taille du fichier téléchargé et le nom de fichier long upfileSize = item.getSize (); String filename = item.getName (); // Obtenez la chaîne de nom de fixe de fichier [] SplitName = filename.split ("//."); String extName = SplitName [SplitName.Length-1]; // Vérifiez le nom du suffixe du fichier pour (chaîne autorisée: alloweDextName) {if (allowing.equalSignoreCase (extname)) {isallowed = true; }} if (! Isallowed) {error = "Le format de fichier de téléchargement est illégal!"; casser; } if (upFileSize> maxSize) {error = "Le fichier que vous téléchargez est trop grand, veuillez sélectionner un fichier qui ne dépasse pas 100 Mo!"; casser; } // À l'heure actuelle, le fichier est temporairement stocké dans la mémoire du serveur, en construisant un fichier d'objet temporaire tempfile = nouveau fichier (makeFileName (fichier)); // Spécifiez le répertoire et le nom du fichier du fichier de fichiers de fichiers de fichiers = nouveau fichier (path + "/" + subdirname + "/", tempfile.getName ()); item.write (fichier); // La première méthode d'écriture du fichier est upFileName = requestPath + "/" + subdirname + "/" + tempfile.getName (); if (upFileName.equals ("")) {error = "pas de sélection pour télécharger le fichier!"; } System.out.println (upFileName); / * // Construisez la deuxième méthode d'écriture du fichier de flux d'entrée de lecture Fichier InputStream est = item.getInputStream (); int length = 0; octet [] par = nouveau octet [1024]; FileoutputStream fos = new FileOutputStream (fichier); while ((longueur = is.read (by))! = - 1) {fos.write (par, 0, longueur); //Thread.sleep(10); } fos.close (); //Thread.sleep(1000); * /} else {error = "pas de sélection pour télécharger le fichier!"; }}}} catch (exception e) {e.printStackTrace (); error = "Erreur s'est produit lors du téléchargement du fichier:" + e.getMessage (); } if (! error.equals ("")) {System.out.println (erreur); session.setAttribute ("erreur", erreur); } else {session.setAttribute ("result", "ok"); session.setAttribute ("FileName", upFileName); }} / ** * Pour empêcher l'écrasement du fichier, un nom de fichier unique doit être généré pour télécharger le fichier * @param nom de fichier nom d'origine * @return le nom de fichier unique généré * / private string makeFileName (String filename) {return uuid.randomuuid (). ToString () + "_" + filename; }} Il est nécessaire de présenter Commons-fileupload-1.3.1.jar et commons-io-2.4.jar
Pendant le processus de téléchargement, nous devons obtenir des informations telles que les progrès de téléchargement en temps réel. La bibliothèque introduite a ajouté une interface ProgressListener pour nous. Nous rédigerons une autre classe pour implémenter cette interface et ajouter cette interface à la classe ci-dessus.
// Créer des objets d'usine et des objets de téléchargement de fichiers DiskFileItemFactory Factory = new DiskFileItemFactory (); ServletFileUpload upload = new ServletFileUpload (Factory); // Créer un écouteur de téléchargement et définir l'écouteur UploadListener écouteur = nouveau uploadListener (); session.setAttribute ("écouteur", auditeur); upload.setProgressListener (écouteur);Vous trouverez ci-dessous le code d'implémentation spécifique de cette classe d'écoute
package util.upload; import org.apache.commons.fileupload.progressListener; public class uploadListener implémente ProgressListener {private volatile long bytesRead = 0l, // nombre d'ytes uploded contenuLength = 0l, // nombre total d'ytes élément = 0l; public uploadListener () {super (); } @Override public void Update (long abytesRead, long acontentLength, int anitem) {bytesRead = abytesRead; contentLength = acontentLength; item = anitem; } public long getBytesRead () {return bytesRead; } public long getContentLength () {return contentLength; } public long getItem () {return item; }}Vous pouvez désormais obtenir des informations telles que les progrès de téléchargement, mais vous avez toujours besoin d'un servlet pour revenir à l'avant. La mise en œuvre suivante
package util.upload; import java.io.ioException; import java.io.printwriter; import java.util.hashmap; import java.util.map; import javax.servlet.servletException; import javax.servlet.http.httpservlet; import javax.servlet.http.httplets; javax.servlet.http.httpservletResponse; import javax.servlet.http.httpcession; import org.apache.commons.fileupload.progressListener; import com.google.gson.gson; / ** get upload progress, upload promed, upload résultat et autres informations * / classe publique Getprogress HttpServlet {private static final long SerialVersionUID = -3596466520775012991l; Protected void doGet (HttpServLetRequest Request, HttpServletResponse Response) lève ServletException, ioException {doPost (request, réponse); } Protected void doPost (httpsservletRequest request, httpServletResponse réponse) lève ServletException, ioException {request.SetcharAtterencoding ("utf-8"); Response.SetcharAtterencoding ("UTF-8"); UploadListener écouteur = null; HttpSession session = request.getSession (); String error = (string) session.getAttribute ("Error"); String result = (string) session.getAttribute ("result"); String filename = (string) session.getAttribute ("FileName"); Printwriter out = réponse.getWriter (); long bytesRead = 0, contentLength = 0; if (session! = null) {écouteur = (uploadListener) session.getAttribute ("écouteur"); if (écouteur == null) {return; } else {bytesRead = auditer.getBytesRead (); // Le nombre de bytes téléchargés ContentLength = écouteur.GetContentLength (); // Total Bytes} // Le format de retour défini par vous-même est String RP = BytesRead + "," + ContentLength + "," + Errear + "," + résultat + "" "+ filename; //System.out.println(rp); Out.print (RP); / * // return json format data map <string, object> map = new hashmap <string, object> (); map.put ("bytesRead", bytesRead); map.put ("ContentLength", ContentLength); map.put ("erreur", erreur); map.put ("résultat", résultat); map.put ("nom de fichier", nom de fichier); Gson gson = new gson (); String json = gson.tojson (map); out.print (json); * / out.flush (); out.close (); }}}Le code de fonction téléchargé en arrière-plan a été écrit. Ce qui suit est le front-end pour implémenter le téléchargement, tout d'abord, HTML
<! Doctype html> <html> <éadf> <meta charset = "utf-8" /> <script type = "text / javascript" src = "js / upfile.js" charset = "utf-8"> </ script> <link rel = "Stylesheet" type = "text / css" href = "css / upfile. > <a href = "javascript: addone ()"> add </a> <div id = "cible"> <input type = "file" id = "file" name = "file" onChange = "addFile (event)" multiple /> </ div> <span id = "test"> 0 </span> </ body> </html>
L'interface est relativement simple, ajoutez simplement une balise et l'entrée téléchargée est masquée.
Affichage de la progression du téléchargement du rendu principal du fichier CSS
#File {affichage: aucun; } .pro {width: 500px; } .pborder {position: relative; Largeur: 500px; / * Largeur * / bordure: 1px solide # b1d632; rembourrage: 1px; } .drawpro {width: 0px; Affichage: bloc; Position: relative; Contexte: # B1D632; Couleur: # 333333; hauteur: 20px; / * Hauteur * / line-height: 20px; / * Il doit être cohérent avec la hauteur avant que le texte ne puisse être centré verticalement * /} .pspan {position: absolu; Largeur: 500px; Texte-aligne: Centre; Police-poids: Bold; }Ensuite, le fichier js frontal focus, js
// le htmlvar upfile_html qui affiche les informations de téléchargement est '<div> <div>' + '<span> 0% </span> </div> </ divload / images / spann name = "path"> </ span> <img src = "Common / upload / images / del.png" style = "float: droit" name = "del" OnClick = aborpupup (this) "Target"; // L'idvar du Div cible Div pour télécharger le fichier httpxml = null; // l'objet xmlhttpRequest qui envoie la demande de téléchargement var httppprogress = null; // xmlhttprequest objet qui envoie des informations de progression de demande var uplist = new Array (); // enregistrer la liste des informations sur les jeux existants Vars Array (); // Enregistrez la liste des fichiers téléchargés var f_input; // téléchargez l'objet d'entrée qui télécharge le fichier var flag = true; // peut-il le fichier suivant var uurl = "upload"; // demande de téléchargement du fichier urlvar gurl = "getProgress"; 0; // idvar ID du fichier étant téléchargé = 0; // id du dernier fichier dans l'objet file d'attente / ** * Fichier * / fonction uploadfile (id, file) {this.id = id; this.file = fichier; this.state = 0; this.path = "";} / ** * Méthode d'initialisation * / window.onload = function init () {f_input = document.getElementyid ("file"); var tdiv = document.getElementById (TargetDiv_id); var oldspan = tdiv.getElementsByTagName ("span"); for (var i = 0; i <oldspan.length; i ++) {oldfilelist.push (oldspan [i] .getAttribute ("name")); }} / ** * Sélectionnez un fichier à télécharger * / fonction addOne () {f_input.value = null; f_input.click ();} / ** * Après avoir sélectionné le fichier, ajoutez l'objet de fichier à la file d'attente et démarrez le téléchargement * * / fonction addFile (evt) {var f = f_input.files [0]; if (f! = Undefined) {var uf = new uploadFile (id, f); uplist.push (uf); var div = document.CreateElement ("div"); div.setAttribute ("id", "pro" + (id)); div.setAttribute ("class", "pro"); div.innerhtml = upfile_html; var TargetDiv = document.getElementById (TargetDiv_id); TargetDiv.ApendChild (Div); div.getElementsByTagName ("Span") [1] .InnerHtml = "Nom de fichier:" + uplist [id] .file.name; waittimer = setInterval ("upload ()", 1000); Id ++; }} / ** * Téléchargez le fichier dans la file d'attente * / fonction upload () {if (flag == true) {if (uplist.length> 0) {var uf; for (var i = 0; i <uplist.length; i ++) {if (uplist [i] .state == 0) {uf = uplist [i]; uplist [i] .state = 1; casser; }} if (uf! = undefined & uf! = null) {flag = false; if (window.xmlhttpRequest) {httpup = new xmlHttpRequest (); } else if (window.activexObject) {httpup = new activeXObject ("Microsoft.xmlhttp"); } var formdata = new formData (); formdata.append ("fichier", uf.file); httpup.open ("post", uurl, true); httpup.upload.addeventListener («progress», uploadProgress, false); httpup.send (formdata); nowId = uf.id; timer = setInterval ("getp ()", 50); }}}} / ** * Obtenir des informations telles que la progression de téléchargement * / fonction getp () {if (window.xmlhttpRequest) {httppprogress = new xmlHttpRequest (); } else if (window.activexObject) {httpprogress = new activeXObject ("Microsoft.xmlhttp"); } httpprogress.onreadystateChange = onProgress; httpprogress.open ("post", gurl, true); httpprogress.setRequestHeader ("contenu-type", "application / x-www-form-urlencoded"); httpprogress.send ("& timestamp =" + (new Date ()). getTime ());} / ** * traitez les informations de téléchargement renvoyées et affichez-la dans l'interface * / fonction onProgress () {if (httpprogress.readystate == 4 && httpprogress; var result = result.replace (/ (^ / s *) | (/ s * $) / g, ""); var res = result.split (","); var maintenant = parseInt (res [0]); var all = paSeInt (res [1]); var err = res [2]; var état = res [3]; var path = res [4]; var per = (maintenant / all * 100) .tofixed (2); var prodiv = document.getElementById ("pro" + nowId); if (prodiv! = null & prodiv! = Undefined) {if (err! = "" & err! = null & err.length> 0) {window.clearinterval (timer); if (cancelflag == 1) {err = "Télécharger la terminaison"; cancelflag = 0; } prodiv.getElementsByTagName ("div") [0] .style.display = "Aucun"; prodiv.getElementsByTagName ("span") [1] .InnerHtml = err; httpup.abort (); Flag = true; upList [NowId] .State = 3; retour; } if (state == "ok") {prodiv.getElementsByTagName ("div") [0] .style.display = "Aucun"; var tmpf = uplist [nowid] .file; prodiv.getElementsByTagName ("span") [1] .InnerHtml = "Nom de fichier:" + tmpf.name; window.ClearInterval (temporisateur); Flag = true; upList [NowId] .State = 2; upList [NowId] .Path = Path; retour; } prodiv.getElementsByTagName ("div") [1] .style.width = per * 5 + "px"; prodiv.getElementsByTagName ("span") [0] .InnerHtml = per + "%"; }}} / ** * Méthode pour annuler le téléchargement * / fonction abortupload (obj) {var idstr = obj.parentNode.id; var id = idstr.slice (3); if (uplist [id] .state == 1) {httpup.abort (); Flag = true; cancflag = 1; } else {uplist [id] .state = 3; } document.getElementById (idStr) .Remove ();} / ** * Obtenez le chemin de téléchargement de fichiers * @return String formated * / function getFileListtr () {var str = ""; if (oldfilelist.length> 0) {for (var i = 0; i <oldfilelist.length; i ++) {if (oldfilelist [i]! = null & oldfilelist [i]! = "" & oldfilelist [i]! = Undefined) {str = str + oldfileList [i] + ",";; }}} pour (var i = 0; i <uplist.length; i ++) {var f = uplist [i]; if (f.state == 2) {str = str + f.path + ","; }} return str;} / ** * supprimer l'ancienne pièce jointe qui était déjà là lorsque la modification * * / fonction supprime (btn) {var num = btn.getAttribute ("name"); OldFileList [num - 1] = null; btn.parentNode.Remove ();} fonction uploadProgress (e) {if (e.Lengthcompotable) {var iBytesuploaded = e.loaded; var ibytestotal = e.total; document.getElementById ("test"). innerHtml = iBytesuploaded + "/" + iByTestotal; }} Utilisez AJAX pour envoyer des fichiers de téléchargement pour obtenir des progrès, des résultats et d'autres informations.
L'API de fichier HTML5 utilisé est donc IE9 ou supérieure à être compatible. Firefox a un problème. Les demandes AJAX ne reviennent pas immédiatement. Le même résultat sera retourné jusqu'à ce que toutes les demandes AJAX soient envoyées, ce qui entraînera la progression du téléchargement qui ne sera pas affiché. Cependant, vous pouvez également utiliser l'API de fichier HTML5 pour l'obtenir, qui a un petit code ajouté. La valeur dans le test de test ci-dessous la page est la progression obtenue à l'avant.
Tous les fichiers téléchargés ont été implémentés, puis les fichiers temporaires téléchargés sont traités. Étant donné que les fichiers nommés UUID sont utilisés, de nombreux fichiers seront générés et ceux inutiles doivent être traités régulièrement. Utilisation de servletContextListener:
Il existe une interface ServletContextListener dans l'API Servlet, qui peut écouter le cycle de vie de l'objet ServletContext, qui est en fait le cycle de vie de l'application Web.
Lorsque le conteneur servlet démarre ou termine une application Web, l'événement ServletContexTevent est déclenché, qui est géré par le servletContextListener. Deux méthodes sont définies dans l'interface ServletContextListener pour gérer l'événement ServletContexTevent.
En utilisant ses fonctionnalités, la fonction de supprimer régulièrement des fichiers temporaires est réalisée. Le code est le suivant:
package util.upload; import java.io.ioException; import java.io.inputstream; import java.util.date; import java.util.properties; import java.util.timer; import java.util.timertask; javax.servlet.servletContextListener; / ** * écouteur de temps * * * / classe publique TempFileListener implémente servletContextListener {tirage privé Timer; SystemTaskTest SystemTask privé; chaîne statique privée every_time_run; statique {Properties prop = new Properties (); InputStream inirem = tempFileManager.class.getClassloader () .getResourceSstream ("tempfile.properties"); essayez {prop.load (inirem); System.out.println (inirem); every_time_run = prop.getProperty ("every_time_run"); } catch (ioException e) {e.printStackTrace (); } enfin {try {inirem.close (); } catch (ioException e) {e.printStackTrace (); }}} // Méthode initiale de l'écoute publique public ContexteInitialized (ServletContexTevent SCCE) {timer = new Timer (); SystemTask = new SystemTaskTest (sce.getServletContext () .getRealPath ("/"), sce.getServletContext ()); essayez {System.out.println ("Timer Started"); // L'auditeur obtient le répertoire racine du site Web String Path = sccE.getServletContext (). GetRealPath ("/"); Long time = long.parselong (every_time_run) * 1000; // l'heure pour Loop Execution System.out.println ("time" + heure); // Le premier paramètre est le code à exécuter, le deuxième paramètre est quand il commence à s'exécuter, et le troisième paramètre est la fréquence à laquelle il s'exécute. Répéter l'exécution de Timer.Schedule (SystemTask, 10000, temps); System.out.println ("Horaire de tâches a été ajouté"); } catch (exception e) {e.printStackTrace (); }} public void contextDestRoyed (servletContexTevent Scaling) {try {timer.cancel (); } catch (exception e) {}}} / ** * Time Tasker * * / class SystemTaskTest étend Timertask {Private ServletContext Context; Path de chaîne privé; public systemTaskTest (String Path, ServletContext Context) {this.path = path; this.context = context; } / ** * Mettez la tâche à exécuter régulièrement dans run * / public void run () {tempfileManager etf; essayez {System.out.println ("Démarrer la tâche!"); // code à exécuter System.out.println (new Date (). TolocaleString ()); ETF = nouveau TempFileManager (chemin); etf.run (); System.out.println ("Spécifiez l'exécution de la tâche terminée!"); } catch (exception e) {e.printStackTrace (); }}}Ce qui précède est juste un auditeur, qui est responsable d'appeler la méthode pour supprimer régulièrement des fichiers temporaires. L'implémentation spécifique est la classe suivante
package util.upload; import java.io.file; import java.io.ioexception; import java.io.inputStream; import java.util.date; import java.util.properties; / ** * supprimer le fichier sur le serveur * * / public class tempfilemanager implémente {private String path L'heure du stockage de fichiers est un jour statique {Properties prop = new Properties (); InputStream inirem = tempFileManager.class.getClassloadher () .getResourceSstream ("eecl.properties"); essayez {prop.load (inirem); Retente_time = prop.getProperty ("file_retention_time"); } catch (ioException e) {e.printStackTrace (); } enfin {try {inirem.close (); } catch (ioException e) {e.printStackTrace (); }}} / ** * Constructeur. Paramètres d'initialisation * @param path * / public tempFileManager (String Path) {this.path = path; } / ** * Mettez le code que le thread souhaite exécuter dans run () * / public void run () {System.out.println ("Management de fichiers start ========================================================== DeleteFiles (fichier);} / ** * Batch Delete Files * * @Param Folder * / public void DeleteFiles (Fichier Fichier) {if (Folder.isDirectory ()) {Fichier [] Fichiers = Folder.ListAbsoL if (candéleteFile (dossier)) {if (dossier.delete ()) {System.out.println ("Folder" + Folder.getName () "Folder" + Folder.GetName () System.out.print dans ce dossier peut être utilisé "); i = 0; i <files qui répondent aux critères if (candéletefile (file)) {if (file.delete ()) {System.out.println ("file" + file.getName () + "Delete Successftactilay!"); } else {System.out.println ("file" + file.getName () + "Delete a échoué! Ce fichier peut être utilisé"); }} else {}} else {System.out.println ("pas de fichier à supprimer"); }} catch (exception e) {System.out.println ("Delete Fichier Faiched ==========="); e.printStackTrace (); }} / ** * Déterminez si le fichier peut être supprimé * / booléen privé candéletefile (fichier de fichier) {date filedate = getFiledate (fichier); Date de date = new Date (); Long temps = (date.getTime () - filedate.getTime ()) / 1000/60 - Integer.ParseInt (retente_time); // les minutes entre l'heure actuelle et l'intervalle de fichier // System.out.println ("time ==" + time); if (time> 0) {return true; } else {return false; }} / ** * Obtenez la dernière heure de modification du fichier * * @param fichier * @return * / private date getFileDate (fichier file) {long ModifiedTime = file.lastmodified (); Date D = nouvelle date (ModifiedTime); retour d; }}Déterminez si le fichier a expiré et que le dossier peut être supprimé automatiquement s'il a expiré.
Ce qui précède concerne cet article, j'espère qu'il sera utile pour tout le monde d'apprendre la programmation Java.