Cargar y descargar archivos es muy común durante el desarrollo. Aquí hay un breve resumen:
1. Condiciones que deben cumplirse para la carga de archivos:
a. El método del formulario de página debe ser publicado porque los datos transmitidos por Get son demasiado pequeños
b. El enctype del formulario de página debe ser de tipo multipart/formulario de datos
do. El formulario proporciona detalles de la carga de código de campo de entrada: en el formulario del cliente: <form de enctype = "multipart/form-data"/>
(Si esta propiedad no está disponible, la ruta del archivo leída por el servidor variará según el navegador)
Servidor ServletInputStream es = request.getInputStream (); obtiene el contenido del cuerpo de solicitud en un flujo para su posterior análisis.
2. Detalles de la carga de archivos:
(1) ¿Por qué establecer el tipo de formulario en: multipart/formularios de formato? Es para establecer el valor aprobado por este formulario que no es el valor clave =. Lo que se pasa es bytecode.
La correspondencia entre el formulario y la solicitud:
Como se muestra arriba, puede ver que después de configurar el tipo de formulario en: multipart/forma de formato, el archivo que seleccionó se inicializa en binario en el cuerpo de solicitud HTTP, como se muestra en la imagen de arriba debajo de una cadena aleatoria debajo de la cookie.
Pero tenga en cuenta que hay dos líneas especiales de caracteres en el archivo de bytecodo dividido por el archivo de identificación (es decir, una cadena de cadenas aleatorias), a saber, la primera línea de encabezado del archivo de contenido y una línea de líneas en blanco. La tercera línea después de eso es el contenido del archivo binario.
Por lo tanto, cuando el servidor acepta archivos cargados por el cliente, al obtener el archivo binario en los parámetros de solicitud HTTP, se deben eliminar las primeras tres líneas.
3. Analice manualmente el archivo txt cargado:
import java.io.bufferedReader; import java.io.ioexception; import java.io.inputstream; import java.io.inputstreamreader; import java.io.printwriter; import javax.servlet.servletexception; import javax.servlet.http.httpservlet; import; importar; import javax.servlet.http.httpservletRequest; import javax.servlet.http.httpservletResponse;/** * Si el tipo de forma es post y el cifrado es multipart/forma * entonces todos los datos se pasan al servidor en modo binario. * Entonces req.getParameter ("xxx") siempre es nulo. * Solo puede obtener datos a través de req.getInputStream () y obtener los datos del texto * * @author wangxi * */public class upServlet extiende httpservlet {public void dopost (httpservletRequest req, htttpSeSponseSponse ServletException, iOException, iOException {req.setcharAcentoding ("; String txt = req.getParameter ("txt"); // El retorno es nulo system.err.println ("txt es:"+txt); System.err.println ("==========================================="); InputStream in = req.getInputStream (); // byte [] b = new Byte [1024]; // int Len = 0; // while ((len = in.read (b))! =-1) {// cadena s = nuevo string (b, b, 0, len); // system.err.print (s); //} bufferederreer Readererreer Readererererererer (new BufferedReader ReaderedereRer Readerederreer Readeredererererererererererererererador (new Buffereerer); String FirstLine = br.readline (); // Leer la primera línea, y la primera línea es un símbolo delimitado, es decir, una cadena aleatoria de cadena filename = br.readline (); // La segunda línea de información del archivo, e intercepta el nombre del archivo desde el nombre de archivo = nombre de archivo.substring (filename.lastindexof ("//")+1); // xxx.text "fileNeMame" FileName.Substring (0, nombre de archivo.length ()-1); while ((data = br.readline ())! = NULL) {if (data.equals (FirstLine+"-")) {break; 4. Use Apache-FileUpload para procesar las cargas de archivos:
Marco: se refiere a encapsular el negocio que los usuarios a menudo procesan en un código. Facilite que los usuarios llamen.
El componente (marco) que carga actualmente el archivo:
Apache-FileUplroad-
Orialiy cos 2008 () -
JSP-SMART-SUPLOAD 200m.
Sube el archivo usando fileUpload:
Requiere importar paquetes de terceros:
Apache-FileUpload.jar El archivo carga el paquete principal.
Apache-commons-io.jar Este paquete es un paquete de dependencia para fileUpload. También es un kit de herramientas.
Categoría central:
DiskFileItemFactory establece espacio en disco y guarda archivos temporales. Solo una clase.
SERVLETFILEUPLOAD: la clase principal para las cargas de archivos, que recibe solicitudes y analizados reqeust.
ServletFileUpload.Parserequest (requDest) - List <FileItem>
Nota: Un FileItem es el comienzo de un logotipo: -------- 243243242342 a -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Paso 1: Importar el paquete:
Paso 2: Escriba un servlet para completar el método Dopost
/*** Dos parámetros construidos por DiskFileItemFactory* El primer parámetro: Sizethreadhold - Establece cuántos bytes de datos para guardar en la caché (memoria), el valor predeterminado es 10k* Si un archivo no es mayor de 10k, solo puede usar la memoria para guardarlo directamente en un archivo. * Si un archivo es superior a 10k, primero debe guardar el archivo en un directorio temporal. * El segundo archivo de parámetros se refiere a la ubicación del directorio temporal * */public class Up2Servlet extiende httpServlet {public void dopost (httpservletRequest req, httpservletResponse resp) lanza servletException, ioexception {req.setcharacterIncoding ("Utf-8"); // Obtener la ruta de la ruta de cadena del proyecto = getServletContext (). GetRealPath ("/up"); // El primer paso declara la clase de fábrica DISKFILEITEMFACTORY, que se utiliza para establecer un directorio temporal en el disco, diskFileItemFactory disk = new DiskFileItemFactory (1024*10, nuevo archivo ("/home/wang/")); // El segundo paso: declare servletFileUpoload y reciba el directorio temporal anterior ServletFileUpload up = new ServletFileUpload (disco); // El tercer paso: PARSE SOLICITA PRUEBA {LIST <StilEitem> list = up.parserequest (req); // Si solo un archivo fileitem file = list.get (0); // Obtenga el nombre del archivo con la stry string filename = file.getName (); FileName = FileName.Substring (FileName.lastIndexof ("//")+1); // Obtener el tipo de archivo String fileType = file.getContentType (); // Obtener el bytecode inputStream en = file.getInputStream (); // declarar la salida de byte stream outstream out = new FileOutputStream (Path+"/"+FileName); // File Copy Byte [] b = nuevo byte [1024]; int len = 0; while ((len = in.read (b))! =-1) {out.write (b, 0, len); } out.close (); tamaño largo = file.getInputStream (). disponible (); // Eliminar el archivo temporal cargado de archivo.delete (); // Mostrar datos resp.setContentType ("text/html; charset = utf-8"); PrintWriter op = resp.getwriter (); op.print ("archivo cargado correctamente <br/> nombre del archivo:"+nombre de archivo); OP.print ("<br/> Tipo de archivo:"+Tipo de filete); op.print ("<br/> tamaño de archivo (bytes)"+tamaño); } catch (Exception e) {E.PrintStackTrace (); }}}5. Use este marco para cargar varios archivos:
Paso 1: Modifique el formulario de la página a múltiples tipos de entrada = "archivo"
<Form Action = "<c: url value = '/up3servlet' //>" método = "post" enctype = "multipart/form-data"> file1: <input type = "file" name = "txt"> <br/> file2: <input type = "file" file "name =" txt "> <br/> <input type =" enviar "/> </form>
Paso 2: Lista de Traverse
public class UP3Servlet extiende httpservlet {public void dopost (httpservletRequest solicitud, respuesta httpServletResponse) lanza ServletException, ioexception {request.setcharacterEncoding ("UTF-8"); String ruta = getServletContext (). GetRealPath ("/up"); // declarar disco diskFileItemFactory disk = new DiskFileItemFactory (); disco.setsizethreshold (1024*1024); disk.setRepository (nuevo archivo ("d:/a")); // declara el servlet que analiza la solicitud ServletFileUpload up = new ServletFileUpload (disco); Pruebe {// Resuelva la lista de solicitudes <SchilItem> list = up.parserequest (request); // declarar una lista <s map> Encapsular los datos de la lista de archivos cargados <map <string, string >> ups = new ArrayList <map <string, string >> (); for (archivo fileitem: list) {map <string, string> mm = new Hashmap <String, String> (); // Obtenga el nombre del archivo String filename = file.getName (); FileName = FileName.Substring (FileName.lastIndexof ("//")+1); Cadena filetype = file.getContentType (); InputStream in = file.getInputStream (); int size = in.available (); // use la clase de herramienta fileUtils.copyInputStreamToFile (in, nuevo archivo (ruta+"/"+nombre de archivo)); mm.put ("nombre de archivo", nombre de archivo); mm.put ("FilEtype", FileType); mm.put ("size", "+size); ups.add (mm); file.delete ();} request.setAttribute (" UPS ", UPS); // reenviar request.getRequestDisPatcher ("/jsps/show.jsp "). reenviar (solicitud, respuesta);} Catch (Exception E) {E.PrintstActAtrace ();}}}Lo anterior es el método común para cargar archivos. Ahora echemos un vistazo a las otras API de búsqueda de FileUpload.
Determine si un FileItem es un objeto File (Type = File) o un Objeto Text (Type = Text | CheckBox | Radio):
boolean isformfield () Si es texto | casilla de verificación | radio | seleccionar, el valor es verdadero.
6. Procesar imágenes con información de descripción
La clase pública UpdesCServlet extiende httpservlet {public void dopost (httpservletRequest request, httpservletResponse respuesta) lanza ServletException, ioexception {request.setcharacterEncoding ("utf-8"); // puede obtener el nombre de archivo chino string path = getRetTcontext (). DiskFileItemFactory disk = new DiskFileItemFactory (); disk.setRepository (nuevo archivo ("d:/a")); intente {servletFileUpload up = new ServLetFileUpload (disco); List <StilEitem> list = up.parserequest (solicitud); para (archivo fileItem: list) {// Paso 1: Determine si es un elemento de formulario ordinario if (file.isformfield ()) {string filename = file.getFieldName (); // <input type = "text" name = "descigu"> = Desc string value = file.getString ("utf-8"); // por defecto, leer datos IN ISO, System.erR.Praintln (fileNeMe+"+"+"+"+" } else {// indica que es una cadena de archivo filename = file.getName (); FileName = FileName.Substring (FileName.lastIndexof ("//")+1); file.write (nuevo archivo (ruta+"/"+nombre de archivo)); System.err.println ("El nombre del archivo es:"+nombre de archivo); System.err.println ("El tamaño del archivo es:"+file.getSize ()); file.delete (); }}} Catch (Exception e) {E.PrintStackTrace (); }}} 7. Rendimiento mejorado de la carga de archivos
Al analizar la solicitud para obtener la colección FileItem, use:
Fileitemiterator it = up.getItemIterator (solicitud);
En comparación con el uso
List <StilEitem> list = up.parserequest (solicitud);
Mucho mejor rendimiento.
Código de muestra:
Fastservlet de clase pública extiende httpservlet {public void dopost (httpservletRequest solicitud, respuesta httpservletResponse) lanza ServletException, ioexception {request.setcharacterEncoding ("UTF-8"); String ruta = getServletContext (). GetRealPath ("/up"); DiskFileItemFactory disk = new DiskFileItemFactory (); disk.setRepository (nuevo archivo ("d:/a")); intente {servletFileUpload up = new ServLetFileUpload (disco); // El siguiente es el modo iterador fileitemIterator it = up.getItemIterator (solicitud); while (it.hasnext ()) {fileItemStream item = it.next (); Cadena filename = item.getName (); FileName = FileName.Substring (FileName.lastIndexof ("//")+1); InputStream in = item.OpenStream (); FileUtils.CopyInputStreamToFile (in, nuevo archivo (Path+"/"+FileName)); }} catch (Exception e) {E.PrintStackTrace (); }}} 8. Descargar archivo
Puede ser obteniendo o publicado.
public void dopost (httpservletRequest req, httpservletResponse resp) lanza ServletException, ioexception {req.setcharacterEncoding ("utf-8"); Name de cadena = req.getParameter ("nombre"); // Paso 1: Establezca el tipo de respuesta resp.setContentType ("Application/Force-Download"); // El segundo archivo de lectura String Path = GetServletContext (). GetRealPath ("/up/"+name); InputStream in = new FileInputStream (ruta); // Establecer el encabezado de respuesta // Codificación de URL de usert del nombre del nombre del archivo = urlencoder.enDode (nombre, "UTF-8"); resp.setheader ("Disposición de contenido", "Adjunto; FileName ="+Name); resp.setContentLength (in.available ()); // Paso 3: Inicie el archivo Copy outputStream out = resp.getOutputStream (); byte [] b = nuevo byte [1024]; int len = 0; while ((len = in.read (b))! =-1) {out.write (b, 0, len); } out.close (); cercar(); } Al usar el marco popular de J2EEEs más fácil usar la encapsulación interna del marco para completar la carga y descargar:
Struts2 está cargado.
Cuando se usa Struts2 para el desarrollo, no es difícil encontrar que el paquete Commons-FileUpload-1.3.1.JAR esté presente en el paquete JAR importado. A través del aprendizaje anterior, ya podemos usarlo para cargar y descargar archivos. Pero Struts2 está experimentando una encapsulación adicional.
vista
<form de acción = "fileUpload.action" método = "post" enctype = "multipart/form-data"> username: <input type = "text" name = "username"> <br> file: <input type = "file" name = "file"> <br> <input type = "enviar" valor = "enviar"> </form>
Controlador
Public Class FileUploadaction extiende ActionSupport {private String UserName; // Tenga en cuenta que el archivo no se refiere al archivo en sí cargado por el JSP frontal, sino el archivo cargado para almacenar el archivo de archivo privado en la carpeta temporal; // El nombre del archivo enviado // Struts interceptará automáticamente el nombre del último archivo y lo inyectará en esta propiedad de cadena privada FileFileName; // getter y setter se guardan en este momento para guardar espacio @Override public String Execute () lanza la excepción {// Guardar la ruta para cargar el archivo String root = servletactionContext.getServletContext (). GetRealPath ("/upload"); // Obtener un archivo temporal de entrada de entrada inputStream es = nuevo fileInputStream (archivo); // El archivo de salida OutputStream OS = nuevo FileOutputStream (nuevo archivo (root, fileFileName)); // Imprima el nombre del archivo del sistema de archivos cargado.out.println ("fileFileName:" + fileFileName); // Debido a que el archivo es un archivo almacenado en una carpeta temporal, podemos imprimir su nombre de archivo y ruta de archivo para ver si es el mismo que el archivo de archivo anterior System.out.println ("file:" + file.getName ()); System.out.println ("archivo:" + file.getpath ()); byte [] buffer = new Byte [1024]; int longitud = 0; while (-1! = (longitud = is.read (buffer, 0, buffer.length))) {os.write (buffer); } os.close (); is.close (); devolver el éxito; }}En primer lugar, debemos estar claro que el archivo aquí no se refiere realmente al archivo cargado por JSP. Cuando se carga el archivo, Struts2 buscará primero la ubicación de almacenamiento especificada por Struts.multipart.Savedir (esto está en default.properties) (el valor predeterminado está vacío). Podemos especificar esta ubicación de almacenamiento temporal en Struts2 de nuestro proyecto.
<constant name = "struts.multipart.savedir" value = "/repository"/>
Si Struts.multipart.savedir no está configurado, la dirección especificada por javax.servlet.context.tempdir se usará de forma predeterminada. El servidor determina el valor de javax.servlet.context.tempdir. Por ejemplo: si el contexto de mi proyecto web es ABC y el servidor usa Tomcat, entonces SavePath debería ser %Tomcat_Home %/Work/Catalina/Localhost/ABC_. El nombre del archivo temporal es similar a la carga__1A156008_1373A8615DD__8000_00000001.TMP. El nombre de archivo temporal puede ser diferente cada vez, pero está aproximadamente en este estilo. Y si usa servidores en Eclipse para configurar Tomcat e inicio, entonces el % TomCat_Home % en la dirección anterior no será el directorio raíz Tomcat real en el sistema, pero será la dirección especificada por Eclipse. Por ejemplo, mi dirección local es la siguiente: /home/wang/eclipsejavacode/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/work/catalina/localhost/abc/upload__1A156008_1373a8615dddddddddddddddddddddddddddddd4000 0001.tmp.
Struts2 ha terminado de descargar.
Descargue el archivo Struts2 de manera más simple, simplemente defina una transmisión de entrada y escriba el archivo en la transmisión de entrada. La configuración de clave aún es configurarla en el archivo de configuración de Struts.xml:
Public Class FileDownloadAction extiende ActionSupport {// La ruta para descargar el archivo en la ruta de cadena privada del servidor; // El nombre del archivo del archivo para descargar la cadena privada downloadFileName; // Escribir getter y setter public futStream getdownloadfile () {return servletactionContext.getServletContext (). GetResourceasStream (ruta); } @Override public String Execute () lanza Exception {// La acción actual es SECTOWNODODLOODFileName (xxx); devolver el éxito; }}La acción solo define un flujo de entrada de entrada y luego le proporciona un método getter. A continuación, echemos un vistazo al archivo de configuración de Struts.xml:
<Action name = "FileDownload"> <resultado name = "download" type = "stream"> <param name = "contentDisposition"> adjunto; filename = "$ {downloadFileName}" </amam> <param name = "inputName"> downloadfile </param> </sult> </action>Hay varios lugares donde debemos prestar atención al archivo de configuración de Struts.xml. Primero, el tipo debe definirse como Stream Type_, diciendo Action Este es el resultado de la descarga de archivos. El elemento de resultado generalmente tiene un subelemento Param. Esto se usa para establecer los parámetros al descargar el archivo. El atributo InputName es obtener la secuencia de entrada de archivo en la acción. El nombre debe ser el mismo que el atributo de flujo de entrada en la acción. Luego el atributo ContentDIsPosition. Este atributo generalmente se usa para especificar cómo queremos procesar el archivo descargado. Si el valor es adjunto, aparecerá un cuadro de descarga, lo que permite que el usuario elija si descargar. Si este valor no está configurado, el navegador primero verificará si abrir el archivo descargado. Si puede, abrirá directamente el archivo descargado (por supuesto, no es lo que necesitamos). Otro valor es el nombre de archivo, que es el nombre de descarga del archivo solicitado por el archivo al descargar. Después de configurar esta información, podemos implementar la función de descarga de archivos.
SpringMVC completa la carga:
La vista es exactamente la misma que el ejemplo Struts2. Esto no está escrito.
Controlador:
@Controlador@requestmapping (value = "fileoperate") public class FileOperateAction {@RequestMapping (value = "upload") public string upload (httpservletRequest request,@requitparam ("file") multipartfile photofile) {// la ruta a cargar archivo guarda string dir = request.getSession (). GetServletContext (). GetRealPath ("/")+"cargar"; // La cadena de nombre de archivo original FileName = PhotoFile.GetoriginalFileName (); // Obtenga la cadena de extensión de archivo extname = filename.substring (filename.lastindexof (".")); // Evitar conflictos de nombre de archivo, modifique ligeramente el nombre FileName = FileName.Substring (0, FileName.lastIndexOf ("."))) + System.Nanotime () + ExtName; FileUtils.writyTearRayTofile (nuevo archivo (dir, nombre de archivo), fotofile.getBytes ()); devolver "éxito"; }}SpringMVC Descarga completa:
@RequestMapping ("/descargar") public String download (String FileName, HttpServletRequest Solicitud, respuesta httpServletResponse) {Respuesta.SetcharacterEncoding ("UTF-8"); respuesta.setContentType ("multipart/form-data"); respuesta.setheader ("Disposición de contenido", "Adjunto; FileName =" + FileName); Pruebe {inputStream inputStream = new FileInputStream (nuevo archivo (ruta del archivo); outputStream OS = Response.getOutputStream (); byte [] b = new byte [2048]; int long; while ((longitud = inputStream.read (b))> 0) {OS.Write (b, 0, longitud);} // está cerrado aquí. } Catch (FileNotFoundException E) {E.PrintStackTrace ();Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.