Recientemente, el proyecto debe cargarse un archivo. Después de completar el trabajo, compártalo y tome notas también.
La función de carga se implementa en segundo plano y Java, y el front-end se implementa principalmente en AJAX de JS. El fondo también agrega archivos temporales que se eliminarán regularmente.
El efecto es como se muestra en la imagen
En primer lugar, la clase principal de la función de carga, la siguiente es el código
paquete Util.upload; import java.io.file; import java.io.ioexception; import java.text.simpledateFormat; import java.util.date; import java.util.iterator; import java.util.list; import java.util.uuid; import javax.servlet.servletexception; importar; javax.servlet.http.httpservlet; import javax.servlet.http.httpservletRequest; import javax.servlet.http.httpServletResponse; import javax.servlet.http.httpsession; import org.apolne.commons.fileupload. org.apache.commons.fileupload.disk.diskfileitemFactory; import org.apache.commons.fileupload.servlet.servletfileUpload; public class uploadServlet extiende httpservlet {Versión serial larga estática privada y final = -3100028423713211599 booleano privado se realizó; cadena privada UpFileName; // Defina la matriz con nombre de sufijo legal cadena privada [] permitidoxtName = new String [] {"zip", "rar", // archivo de compresa "txt", "doc", "wps", "docx", "java", // text "xls", "xlsx", // table "ppt", "pptx", // slide "pdf", // reproducir "f" jpg "," bmp "," gif "," png "// pictser HttpServletResponse Respuesta) lanza ServletException, IOException {dopost (request, respuesta); response.setCharacterEncoding("utf-8"); //Get session, save progress and upload results, upload starts as nok, when Ok means uploading is completed HttpSession session=request.getSession(); session.setAttribute("result", "nok"); session.setAttribute("error", ""); String error=""; upFileName=""; isAllowed=false; //Set Un valor máximo para el archivo cargado, que no debe exceder 100MB int maxSize = 100*1024*1024; ServletFileUpload upload = new ServLetFileUpload (fábrica); // Crear un oyente de carga y establecer el oyente de idering listener oyente = new uploadListener (); session.setAttribute ("oyente", oyente); upload.setProgressListener (oyente); // cargar stry string ruta = request.getSession (). GetServletContext (). GetRealPath ("/upload"); String requestPath = request.getSession (). GetServletContext (). GetContextPath ()+"/upload"; Archivo dirfile = nuevo archivo (ruta); //System.out.println(Request.getSession (). GetServletContext (). GetContextPath ()); // Si la carpeta no existe, cree if (! Dirfile .exists () &&! Dirfile .isDirectory ()) {dirfile .mkdir (); } // Cree una carpeta basada en la fecha y guárdela en la carpeta con la fecha de fecha correspondiente Fecha = nueva fecha (); SimpleDateFormat sdf = new SimpleDateFormat ("yyyymmdd"); Cadena subdirname = sdf.format (fecha); Archivo subdirfile = nuevo archivo (ruta+"/"+subdirname); if (! SubdirFile .Exists () &&! } try {// Lista de solicitudes de carga de carga <SchilItem> items = upload.parserequest (solicitud); Iterator <FileItem> ITR = items.iterator (); while (itr.hasnext ()) {fileItem item = (fileItem) itr.next (); // Determinar si es un dominio de archivo if (! Item.isformfield ()) {if (item.getName ()! = NULL &&! Item.getName (). Equals ("")) {// Obtenga el tamaño de archivo cargado y el nombre del archivo Long UpFilesize = item.getSize (); Cadena filename = item.getName (); // Obtenga la cadena de nombre del sufijo del archivo [] splitName = filename.split ("//."); Cadena extname = splitName [splitname.length-1]; // verifique el nombre del sufijo del archivo para (cadena permitida: permitidoextname) {if (permitido.equalSignorEcase (extName)) {isLlowed = true; }} if (! isLlowed) {error = "El formato de archivo de carga es ilegal!"; romper; } if (UPFILSIZE> MaxSize) {Error = "El archivo que cargue es demasiado grande, ¡seleccione un archivo que no exceda los 100mb!"; romper; } // En este momento, el archivo se almacena temporalmente en la memoria del servidor, construyendo un archivo de objeto temporal tempfile = nuevo archivo (MakefileName (FileName)); // Especifique el directorio y el nombre del archivo del archivo del servidor de carga de archivo = nuevo archivo (ruta+"/"+subdirname+"/", tempfile.getName ()); item.write (archivo); // El primer método de escritura del archivo es UpFileName = requestPath+"/"+subdirname+"/"+tempfile.getName (); if (upFileName.equals ("")) {error = "¡No hay selección para cargar archivo!"; } System.out.println (UpFileName); /*// Construye el segundo método de escritura Archivo del archivo de entrada de entrada El archivo InputStream es = item.getInputStream (); int longitud = 0; byte [] by = nuevo byte [1024]; FileOutputStream fos = new FileOutputStream (archivo); while ((longitud = is.read (por))! =-1) {fos.write (por, 0, longitud); //Thread.sleep(10); } fos.close (); //Thread.sleep(1000); */} else {error = "Sin selección para cargar archivo!"; }}}} Catch (Exception e) {E.PrintStackTrace (); error = "Se produjo un error al cargar el archivo:"+E.getMessage (); } if (! Error.equals ("")) {System.out.println (error); session.SetAttribute ("Error", error); } else {session.setAttribute ("resultado", "ok"); session.SetAttribute ("nombre de archivo", UpFileName); }} / *** Para evitar la sobrescritura de archivos, se debe generar un nombre de archivo único para cargar el archivo* @param nombre de archivo original nombre de archivo* @return el nombre de archivo único generado* / private string makefileName (string filename) {return uuid.randomuuid (). ToString () + "_" + filename; }} Es necesario presentar a Commons-FileUpload-1.3.1.Jar y Commons-io-2.4.Jar
Durante el proceso de carga, necesitamos obtener información como el progreso de carga en tiempo real. La biblioteca introducida agregó una interfaz ProgressListener para nosotros. Escribiremos otra clase para implementar esta interfaz y agregaremos esta interfaz a la clase anterior.
// Crear objetos de fábrica y objetos de carga de archivos DiskFileItemFactory Factory = new DiskFileItemFactory (); ServletFileUpload upload = new ServLetFileUpload (fábrica); // Crear un oyente de carga y establecer el oyente de idering listener oyente = new uploadListener (); session.setAttribute ("oyente", oyente); upload.setProgressListener (oyente);A continuación se muestra el código de implementación específico de esta clase de escucha
paquete Util.upload; import org.apache.commons.fileupload.progressListener; public class uploadListener implementa ProgressListener {private volátil volátil largo bytesread = 0l, // Número de bytes cargados ContentLength = 0l, // Número total de bytes ítem = 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; }}Ahora puede obtener información como el progreso de la carga, pero aún necesita un servlet para regresar a la parte delantera. La siguiente implementación
paquete 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.servletp. javax.servlet.http.httpServletResponse; import javax.servlet.http.httpsession; importar org.apache.commons.fileUpload.progressListener; import Com.google.gson.gson;/** Progreso de carga de carga, error de carga, error, resultado de carga y otra información*/Class de pública Extends ExprogressS upprogrsever Httpservlet {private static final long SerialVersionUid = -3596466520775012991l; Doget vacío protegido (solicitud httpservletRequest, respuesta httpservletResponse) lanza ServletException, ioexception {dopost (solicitud, respuesta); } protegido void dopost (httpservletRequest solicitud, respuesta httpservletreSponse) arroja servletException, ioexception {request.setcharacterEncoding ("utf-8"); respuesta.setcharacterEncoding ("UTF-8"); UmbarListener oyente = null; Httpsession session = request.getSession (); String Error = (String) Session.getAttribute ("Error"); String dult = (string) session.getAttribute ("Result"); String filename = (string) session.getAttribute ("FileName"); PrintWriter out = Response.getWriter (); long bytesread = 0, contentLength = 0; if (session! = null) {oyente = (uploadListener) session.getAttribute ("oyente"); if (oyente == null) {return; } else {bytesread = oyearer.getBytesRead (); // El número de bytes cargado contentLength = oyequer.getContentLength (); // total bytes} // El formato de retorno definido por usted es cadena rp = bytesread +"," contentLength +"," +error +" +resultado +", " +nombre de archivo; //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 ("error", error); map.put ("resultado", resultado); map.put ("nombre de archivo", nombre de archivo); Gson gson = new Gson (); Cadena json = gson.tojson (mapa); out.print (json);*/ out.flush (); out.close (); }}}Se ha escrito el código de función cargado en segundo plano. El siguiente es el front-end para implementar la carga, en primer lugar, html
<! Doctype html> <html> <head> <meta charset = "utf-8"/> <script type = "text/javaScript" src = "js/upfile.js" charset = "utf-8"> </script> <ink rel = "stylesheet" type = "text/css" href = "cs/upfileSs> </////////" text/css "href =" cs/upfileSs/<c. <body> <a href = "javascript: addone ()"> add </a> <div id = "target"> <input type = "file" id = "file" name = "file" onchange = "addfile (event)" múltiple/> </div> <span id = "test"> 0 </span> </body> </html>
La interfaz es relativamente simple, solo agregue una etiqueta y la entrada cargada está oculta.
Mostrar el progreso de carga de la representación principal del archivo CSS
#file {Display: None; } .pro {ancho: 500px; } .pborder {posición: relativo; Ancho: 500px; /* Ancho*/ borde: 1px sólido #b1d632; relleno: 1px; } .DrawPro {ancho: 0px; Pantalla: bloque; Posición: relativo; Antecedentes: #B1D632; Color: #333333; Altura: 20px; /* Altura*/ Line-Height: 20px; /* Debe ser consistente con la altura antes de que el texto pueda centrarse verticalmente*/} .pspan {posición: absoluto; Ancho: 500px; Text-Align: Center; Font-Weight: Bold; }El siguiente es el foco front-end, el archivo JS
// El htmlvar upfile_html que muestra información de carga es '<div> <div>' + '<span> 0%</span> </div> </div> <span name = "ruta"> </span> <img src = "común/upload/del.png" style = "float: name =" del "del" itclick = abortuplaad (esto); var TargetDiv_id = "Target"; // El IDVAR del DIV de destino para cargar el archivo httpxml = null; // El objeto xmlhttprequest que envía la solicitud de carga var httprogress = null; // xmlhttprequest Object que envía información de progreso var de la lista de sold de la lista. Array (); // Guardar la lista de archivos cargados var f_input ;// cargar el objeto de entrada que carga el archivo var flag = true; // puede el siguiente archivo de archivo var uurl = "cargar" ;/ solicitud para cargar el archivo urlvar gurl = "getProgress"; // cargar el archivo urlvar cateSflag = 0; // Cancel Var TimeRer; 0; // ID IDVAR del archivo que se está cargando = 0; // id del último archivo en la cola/*** objeto de archivo*/function uploadFile (id, archivo) {this.id = id; this.file = file; this.state = 0; this.path = "";}/*** Método de inicialización*/window.onload = function init () {f_input = document.getElementById ("archivo"); var tdiv = document.getElementById (targetDiv_id); var oldspan = tdiv.getElementsBytagName ("Span"); for (var i = 0; i <oldspan.length; i ++) {OldFilelist.push (OldSpan [i] .getAttribute ("Nombre")); }}/** * Seleccione un archivo para cargar */function addone () {f_input.value = null; f_input.click ();}/*** Después de seleccionar el archivo, agregue el objeto de archivo a la cola y comience a cargar**/function 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 ("clase", "pro"); div.innerhtml = UpFile_html; var TargetDiv = document.getElementById (targetDiv_id); TargetDiv.AppendChild (div); div.getElementsBytagName ("Span") [1] .innerhtml = "Nombre del archivo:" + UpList [id] .File.name; waittimer = setInterval ("upload ()", 1000); Id ++; }}/*** Cargue el archivo en la cola*/function ifoad () {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]; Lista ascendente [i] .state = 1; romper; }} 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 ("archivo", uf.file); httpup.open ("post", uurl, true); httpup.upload.addeventListener ('Progress', uploadProgress, false); httpup.send (FormData); nowid = uf.id; timer = setInterval ("getp ()", 50); }}}}/*** Obtenga información como el progreso de carga*/function getp () {if (window.xmlhttprequest) {httpprogress = new xmlhttprequest (); } else if (window.activexObject) {httpprogress = new ActiveXObject ("Microsoft.xmlhttp"); } httpprogress.OnreadyStateChange = onProgress; httpprogress.open ("post", gurl, verdadero); httpProgress.setRequestHeader ("Content-type", "Application/x-www-form-urlencoded"); httpProgress.send ("& timestamp =" + (new date ()). getTime ());}/*** Procese la información de carga devuelta y muestrala a la interfaz*/function onProgress () {if (httpProgress.readyState == 4 && htttttpPpPPRogress == 200) {result = httpPRoStextEtext; VAR result = result.replace (/(^/s*) | (/s*$)/g, ""); var res = resultado.split (","); var ahora = parseInt (res [0]); var all = parseInt (res [1]); var err = res [2]; estado var = res [3]; ruta var = res [4]; var per = (ahora / all * 100) .tofixed (2); var prodiv = document.getElementById ("pro" + nowid); if (prodiv! = null & prodiv! = Undefined) {if (err! = "" & err! = null & err.length> 0) {window.clearinterval (temporizador); if (cancelflag == 1) {err = "terminación de carga"; cancelflag = 0; } prodiv.getElementsBytagName ("div") [0] .style.display = "none"; prodiv.getElementsBytagName ("Span") [1] .innerhtml = err; httpup.abort (); bandera = verdadero; UpList [NowID] .state = 3; devolver; } if (state == "ok") {prodiv.getElementsByTagName ("div") [0] .style.display = "ninguno"; var tmpf = UpList [NowID] .file; prodiv.getElementsBytagName ("Span") [1] .innerhtml = "Nombre del archivo:" + tmpf.name; Window.ClearInterval (temporizador); bandera = verdadero; uplist [nowid] .state = 2; uplist [nowid] .path = ruta; devolver; } prodiv.getElementsBytagName ("div") [1] .style.width = per * 5 + "px"; prodiv.getElementsBytagName ("Span") [0] .innerhtml = per + "%"; }}}/*** Método para cancelar la carga*/function abortUpload (obj) {var idstr = obj.parentNode.id; var id = idstr.slice (3); if (UpList [id] .state == 1) {httpup.abort (); bandera = verdadero; cancelflag = 1; } else {uplist [id] .state = 3; } document.getElementById (IDSTR) .remove ();}/*** Obtenga la ruta para cargar archivo* @returns String formateado*/function getFileListStr () {var str = ""; if (OldFilelist.length> 0) {for (var i = 0; i <oldFilelist.length; i ++) {if (OldFileList [i]! = NULL & OldFilelist [i]! = "" & OldFileList [i]! = Udefined) {str = Str + OldFilelist [i] + ","; "; }}} para (var i = 0; i <uplist.length; i ++) {var f = uplist [i]; if (f.state == 2) {str = str + f.path + ","; }} return str;}/*** Retire el archivo adjunto anterior que ya estaba allí cuando la modificación**/function Remoughold (btn) {var num = btn.getAttribute ("name"); OldFilelist [num - 1] = nulo; btn.parentnode.remove ();} function uploadProgress (e) {if (e.lengthComputable) {var ibytesuploaded = e.loaded; var ibytestotal = e.total; document.getElementById ("test"). innerhtml = iBytesuploaded+"/"+iByTestotal; }} Use AJAX para enviar archivos de carga para obtener progreso de carga, resultados y otra información.
La API del archivo HTML5 utilizada es, por lo que IE9 o superior debe ser compatible. Firefox tiene un problema. Las solicitudes de AJAX no regresan de inmediato. El mismo resultado se devolverá hasta que se envíen todas las solicitudes AJAX, lo que dará como resultado que el progreso de carga no se muestre. Sin embargo, también puede usar la API del archivo HTML5 para obtenerlo, que tiene un pequeño código agregado. El valor en la prueba Div debajo de la página es el progreso obtenido en la parte delantera.
Se han implementado todos los archivos cargados, y luego se procesan los archivos temporales cargados. Debido a que se utilizan los archivos con nombre de UUID, se generarán muchos archivos y los inútiles deben procesarse regularmente. Uso de servletContextListener:
Hay una interfaz ServletContextListener en la API Servlet, que puede escuchar el ciclo de vida del objeto ServletContext, que en realidad es el ciclo de vida de la aplicación web.
Cuando el contenedor de servlet comienza o termina una aplicación web, se activa el evento ServletContextEvent, que maneja el ServletContextListener. Se definen dos métodos en la interfaz ServletContextListener para manejar el evento ServletContextEvent.
Usando sus características, la función de eliminar archivos temporales regularmente se realiza. El código es el siguiente:
paquete 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; import javax.servlet.servletcontext; importar javax.servlet.servlet.servletconteyTeoTeTeoTeTeoTeTeoTeTeTeo javax.servlet.servletContextListener;/ ** * Time Listener * * */ public class TempFileListener implementa ServletContextListener {Temperador privado temporizador; SystemTaskTest privado SystemTask; cadena estática privada todos_Time_run; static {Propiedades prop = new Properties (); InputStream Instrem = tempfilemanager.class.getClassLoader () .getResourCeasstream ("tempfile.properties"); intente {prop.load (instrem); System.out.println (Instrem); Every_Time_run = prop.getProperty ("Every_Time_run"); } catch (ioException e) {E.PrintStackTrace (); } finalmente {try {instrem.close (); } catch (ioException e) {E.PrintStackTrace (); }}} // Método inicial del oyente public void contextinitialized (servletContextEvent scce) {timer = new Timer (); SystemTask = new SystemTaskTest (sce.getServletContext () .getRealPath ("/"), sce.getServletContext ()); intente {System.out.println ("Timer iniciado"); // El oyente obtiene el directorio root de la ruta del sitio web String = scce.getServletContext (). GetRealPath ("/"); Long Time = Long.parselong (Every_Time_run) * 1000; // El tiempo para la ejecución del bucle System.out.println ("Time" + Time); // El primer parámetro es el código que se ejecutará, el segundo parámetro es cuando comienza a ejecutarse, y el tercer parámetro es con qué frecuencia se está ejecutando. Repetir la ejecución del temporizador.schedule (SystemTask, 10000, tiempo); System.out.println ("Se ha agregado el horario de tareas"); } catch (Exception e) {E.PrintStackTrace (); }} public void contextDestroyed (ServletContextEvent Scaling) {try {timer.cancel (); } Catch (Exception e) {}}} / *** Tasker de tiempo** / class SystemTaskTest extiende TimeTask {contexto privado ServletContext; ruta de cadena privada; Public SystemTaskTest (String Path, ServletContext Context) {this.path = Path; this.context = context; } / *** Ponga la tarea a ejecutarse regularmente en ejecución* / public void run () {tempfilemanager etf; intente {System.out.println ("¡Inicie la tarea!"); // Código para ser ejecutado System.out.println (new Date (). TOLOCALECRING ()); ETF = nuevo tempfilemanager (ruta); etf.run (); System.out.println ("Especifique la ejecución de la tarea se completa!"); } catch (Exception e) {E.PrintStackTrace (); }}}Lo anterior es solo un oyente, que es responsable de llamar al método para eliminar los archivos temporales regularmente. La implementación específica es la siguiente clase
paquete util.upload; import java.io.file; import java.io.ioException; import java.io.inputstream; import java.util.date; import java.util.properties;/*** Eliminar el archivo en el servidor*/clase pública Tempfilemanager implementados rentables {string privado string; // static static static static static static static static static Retents "1440"; // El tiempo para el almacenamiento de archivos es un día estático {Propiedades prop = new Properties (); InputStream Instrem = tempfilemanager.class.getClassLoader () .getResourCeasstream ("execl.properties"); intente {prop.load (instrem); Retención_time = prop.getProperty ("file_retention_time"); } catch (ioException e) {E.PrintStackTrace (); } finalmente {try {instrem.close (); } catch (ioException e) {E.PrintStackTrace (); }}} /*** constructor. Parámetros de inicialización * @param ruta */ public tempfilemanager (string ruta) {this.path = rath; } / *** Pon el código que el hilo quiere ejecutar en run ()* / public void run () {System.out.println ("File Management Start =========================================; ruta; System.Println (" File de gestión de archivo ============================; deletefiles (archivo); if (CandeleteFile (carpeta)) {if (folder.delete ()) {System.out.println ("carpeta" + carpeta.getName () + "Eliminar correctamente!") i = 0; que cumplan con los criterios if (candeleteFile (file)) {if (file.delete ()) {system.out.println ("file" + file.getName () + "eliminar con éxito!"); } else {system.out.println ("file" + file.getName () + "Eliminar fallado! Este archivo se puede usar"); }} else {}} else {system.out.println ("no se eliminará el archivo"); }} Catch (Exception e) {System.out.println ("Eliminar el archivo fallido ============="); E.PrintStackTrace (); }} / *** Determine si el archivo se puede eliminar* / private boolean candeleteFile (archivo de archivo) {date FileDate = getFileDate (archivo); Fecha fecha = nueva fecha (); Long Time = (date.getTime () - Filedate.GetTime ()) / 1000 /60 - Integer.ParseInt (retención_time); // Las actas entre la hora actual y el intervalo de archivo // system.out.println ("Time =="+Time); if (tiempo> 0) {return true; } else {return false; }} / ** * Obtenga la última hora de modificación del archivo * * @param archivo * @return * / private date getFileDate (archivo de archivo) {long modifiedtime = file.lastModified (); Fecha d = nueva fecha (modificado tiempo); regresar D; }}Determine si el archivo se agotó y la carpeta se puede eliminar automáticamente si se agotó.
Lo anterior se trata de este artículo, espero que sea útil para todos aprender la programación de Java.