La última vez hablamos sobre las formas de descargar archivos, en esta ocasión hablaremos brevemente sobre las formas de subir archivos desde diferentes entornos.
Método de carga de archivos Método
Servlet2.5 Método
Servlet3.0 Método
SpringMVC
Práctica de
caso Método Servlet2.5 La
carga de archivos implica la escritura de la página en primer plano y la escritura del código del servidor en segundo plano, el primer plano envía el archivo, el fondo recibe y guarda el archivo, esto es lo que Una carga de archivo completa.
- Página delantera
Al cargar archivos, habrá una interfaz para cargar archivos. Primero, necesitamos un formulario y el método de solicitud del formulario es POST; en segundo lugar, el enctype de nuestro formulario debe establecerse en "multipart / form-data", es decir, enctype = " "multipart / form-data" significa establecer la codificación MIME del formulario. De forma predeterminada, este formato de codificación es "application / x-www-form-urlencoded" y no se puede usar para cargar archivos; solo cuando se usan multipart / form-data se pueden transmitir completamente los datos del archivo.
- El uso de background commons-fileupload
Primero, debe importar el paquete jar de terceros, http://commons.apache.org/ download commons-io y commons-fileupload dos recursos jar. Descomprima e importe al proyecto. commons-fileupload.jar es el paquete principal para la carga de archivos. commons-io.jar es un paquete de dependencia de fileupload y también un kit de herramientas.
Introducir varias clases básicas utilizadas
DiskFileItemFactory: establece el espacio en disco y guarda los archivos temporales. Solo una herramienta
ServletFileUpload: la clase principal para la carga de archivos, esta clase recibe solicitudes y analiza
ServletFileUpload.parseRequest (solicitud); - Lista 解析 solicitud
1. Cree una clase de fábrica DiskFileItemFactory y configure el archivo temporal y el tamaño
2. Cree la clase principal ServletFileUpload, reciba archivos temporales y realice la conversión solicitada
3. Convierta la solicitud original a través de la clase ServletFileUpload para obtener la colección FileItem
4. Recorre y procesa cada elemento de la colección.
5. Determine si cada elemento es un elemento de formulario normal y, si lo es, se procesará como un elemento de formulario normal.
6. Si no es un elemento de formulario normal, es un archivo, que se procesa procesando (cargando)
class UploadServlet extiende el HttpServlet {public Private Long Final static serialVersionUID = 1L; protected void-Service (la solicitud HttpServletRequest, la respuesta HttpServletResponse) lanza ServletException, IOException { // codificación establecida, el nombre del archivo puede adquirirse en chino request.setCharacterEncoding 8 " ); // Obtener la ruta del directorio de carga en tomcat String path = getServletContext (). GetRealPath ("/ upload"); // Directorio de archivos temporales String tempPath = getServletContext (). GetRealPath ("/ temp"); // Verificar ¿Tenemos una solicitud de carga de archivo // booleano isMultipart = ServletFileUpload.isMultipartContent (req); // 1. Declare la clase de fábrica DiskFileItemFactory para configurar un directorio temporal en el disco especificado DiskFileItemFactory disk = new DiskFileItemFactory (1024 * 10, new File ( tempPath));
// 2. Declare ServletFileUpload para recibir el archivo temporal anterior. También puede usar el valor predeterminado
ServletFileUpload up = new ServletFileUpload (disk);
// 3. parse request
try { List list = up.parseRequest (request); if (list.size ()> 0) { for (FileItem file: list) { // Determine si es un elemento de formulario normal si (file.isFormField ()) { String fieldName = file.getFieldName (); // Chino confuso, en este momento, también necesita especificar el método de codificación para obtener datos // Valor de cadena = file.getString (); String value = file.getString ("UTF-8"); System.out.println (fieldName + “=” + value); } else {// La descripción es un archivo // Obtiene el nombre del propio archivo String fileName = file.getName (); System.out.println (file.getFieldName ()); // Nombre del archivo de proceso
fileName = fileName.substring (fileName.lastIndexOf ("") + 1);
System.out.println ("nombre antiguo:" + fileName);
// modificar el nombre
String extName = fileName.substring (fileName.lastIndexOf ("." ));
String newName = UUID.randomUUID (). ToString (). Replace ("-", “”) + extName;
// Guarde el nuevo nombre y escríbalo en el nuevo archivo
file.write (new File (path + "/" + newName));
System.out.println ("El nombre del archivo es:" + fileName);
System.out.println ("El tamaño del archivo es:" + file.getSize ());
file.delete () ;
}
}
}
} la captura (FileUploadException E) { e.printStackTrace (); } la captura (Excepción E) { e.printStackTrace (); } } }
Modo Servlet3.0
Utilice la anotación @MultipartConfig para identificar un servlet como soporte para la carga de archivos. Servlet3.0 encapsula la solicitud POST multipart / form-data en Part y opera el archivo cargado a través de Part.
Mostrador
Entre bastidores
@WebServlet ("/ Upload")
@MultipartConfig
public class UploadServlet extiende el HttpServlet { Private Long Final static serialVersionUID = 1L; protected void-Service (la solicitud HttpServletRequest, la respuesta HttpServletResponse) arroja ServletException, IOExprintln { System.out.archivos ”); // Establecer la codificación request.setCharacterEncoding (" UTF-8 "); // Obtener parámetros de elementos de formulario comunes String uname = request.getParameter (" uname "); System.out.println (uname); // Subir archivo // Obtener el objeto de la pieza request.getpart (nombre): nombre representa el valor del atributo de nombre del elemento del archivo en el formulario Part part = request.getPart ("myfile"); // Obtener la ruta donde se almacena el archivo String path = request.getServletContext ( ) .getRealPath ("/"); // obtener el nombre del archivo
String fileName = part.getSubmittedFileName ();
// 上传
part.write (ruta + nombreArchivo);
} }
La
modificación del archivo SpringMVC Way Pom agrega dependencia de carga de archivos comunes
servlet-context.xml
104857600 4096FileController
java.io.File importación; importación java.io.IOException; importación javax.servlet.http.HttpServletRequest; importación org.springframework.stereotype.Controller; org.springframework.web.bind.annotation.RequestMapping importación; org.springframework.web.multipart.MultipartFile importación; importación org.springframework.web.multipart.MultipartHttpServletRequest; org.springframework.web.servlet.ModelAndView importación; @Controller public class {FileController @RequestMapping ( "/ uploadfile ") pública ModelAndView uploadfile (HttpServletRequest solicitud) {
ModelAndView mv = new ModelAndView (); mv.setViewName ( “número”); MultipartHttpServletRequest mr = (MultipartHttpServletRequest) solicitud; MultipartFile multipartFile = mr.getFile ( “archivo”); String path = request.getSession () . .getServletContext () getRealPath ( “carga”); System.out.println (ruta); si (null && = multipartFile multipartFile.isEmpty ()!) { cadena archivo = multipartFile.getOriginalFilename (); try { multipartFile.transferTo (nuevo archivo (ruta, nombre de archivo)); mv.addObject ( “msg”, “文件上传成功!”); } catch (Exception e) {
mv.addObject ("msg", "¡la carga falló!"); e.printStackTrace (); } } return mv; } }
Forma frontal
EnviarExtensión ~ MIME
MIME (Extensiones de correo de Internet multipropósito) Tipo de extensión de correo de Internet multipropósito. Es una forma de configurar un archivo con una determinada extensión para que sea abierto por una aplicación.Cuando se accede al archivo con la extensión, el navegador utilizará automáticamente la aplicación especificada para abrirlo. Se utiliza principalmente para especificar algunos nombres de archivo definidos por el cliente y algunos métodos de apertura de archivos multimedia.
Es un estándar de Internet que amplía el estándar de correo electrónico para permitirle admitir:
Texto de carácter no ASCII; archivos adjuntos de formato no textual (binario, sonido, imagen, etc.); cuerpo del mensaje compuesto de varias partes; información de encabezado que contiene caracteres no ASCII.
Este estándar está definido en RFC 2045, RFC 2046, RFC 2047, RFC 2048, RFC 2049 y otras RFC. MIME mejora RFC 2822, que se ha transformado de RFC 822. Estos antiguos estándares estipulan que los estándares de correo electrónico no permiten el uso de caracteres fuera del conjunto de caracteres ASCII de 7 bits en los mensajes de correo electrónico. Debido a esto, algunos mensajes de caracteres que no están en inglés y archivos binarios, imágenes, sonidos y otros mensajes que no son de texto no se pueden transmitir en el correo electrónico originalmente (MIME puede). MIME especifica un método simbólico para representar varios tipos de datos. Además, el marco MIME también se utiliza en el protocolo HTTP utilizado en la World Wide Web, y el estándar se extiende a los tipos de medios de Internet.
Para ver los tipos MIME correspondientes a diferentes archivos, recomiendo una forma. Tome Tomcat como ejemplo. El archivo web.xml que se encuentra debajo puede ver todos los tipos MIME. Use Ctrl + F para buscar y encontrar rápidamente el tipo MIME del archivo que desea conocer.