Introducción
Contenido
Cargar archivos en un sitio web no es una tarea poco común, pero tampoco es muy sencillo de lograr. Algunos casos de uso de por qué querría cargar un archivo en un sitio web incluyen servicios que ofrecen conversiones de archivos en línea y sitios web para compartir fotos. En ciertas aplicaciones, es posible que incluso queramos enviar un archivo a otro usuario, etc.
La Spring proporciona una MultipartFile interfaz para manejar solicitudes HTTP de varias partes para cargar archivos. Las solicitudes de archivos de varias partes dividen los archivos grandes en trozos más pequeños, lo que lo hace eficiente para la carga de archivos. Se puede encontrar más información al respecto. aquí.
Configuración del proyecto
Para demostrar la carga de archivos, crearemos una aplicación Spring MVC típica que consta de un Controller, un Service para el procesamiento de backend, y Thymeleaf para ver la representación.
La forma más sencilla de comenzar con un proyecto esqueleto de Spring Boot, como siempre, es usando Spring Initializr. Seleccione su versión preferida de Spring Boot y agregue el Web y Thymeleaf dependencias:
Después de esto, generelo como un proyecto de Maven y ¡listo!
Construyendo la Aplicación
Clase de servicio
Empecemos por construir el Service capa primero. Lo nombraremos como FileService.java:
@Service
public class FileService {
@Value("${app.upload.dir:${user.home}}")
public String uploadDir;
public void uploadFile(MultipartFile file) {
try {
Path copyLocation = Paths
.get(uploadDir + File.separator + StringUtils.cleanPath(file.getOriginalFilename()));
Files.copy(file.getInputStream(), copyLocation, StandardCopyOption.REPLACE_EXISTING);
} catch (Exception e) {
e.printStackTrace();
throw new FileStorageException("Could not store file " + file.getOriginalFilename()
+ ". Please try again!");
}
}
}
Vamos a dividirlo línea por línea:
@Servicees una especialización del@Componentanotación. Le dice a Spring que esta es una clase de servicio. Normalmente, toda la lógica empresarial se escribe en esta capa.- Entonces tenemos una variable
uploadDir, que usaremos para almacenar la ruta del directorio en el que queremos que se cargue nuestro archivo. Está anotado con@Value, lo que significa que su valor puede ser establecido por elapplication.propertiesarchivo por elapp.upload.dirllave. En caso de que esta clave no esté definida, el valor predeterminado esuser.home– que se encuentra en una variable de entorno de cada sistema operativo. - Entonces tenemos un método público
uploadFileque toma en unMultipartFilecomo argumento. - Luego creamos el
Pathdel archivo utilizando elPathsclase proporcionada por Java.StringUtils.cleanPathse usa para limpiar el camino y simplemente agregamosuploadDira ella usando unFile.separator. Utilice siempre métodos de utilidad para manejar rutas en el código porque manejará automáticamente diferentes implementaciones de SO. Por ejemplo, en Windows, el separador de archivos esmientras que en Linux es/. - Luego copiamos el archivo a la ubicación usando
Files.copy. losREPLACE_EXISTINGLa opción de copia anulará cualquier archivo con el mismo nombre allí. - Si hay un
Exceptionen todo este proceso lo capturamos y lanzamos una costumbreFileStorageExceptionexcepción.
Excepción personalizada
Escribimos una costumbre FileStorageException para cualquier excepción durante el proceso de carga del archivo. Es una clase simple que se extiende RuntimeException:
public class FileStorageException extends RuntimeException {
private static final long serialVersionUID = 1L;
private String msg;
public FileStorageException(String msg) {
this.msg = msg;
}
public String getMsg() {
return msg;
}
}
Para poder usar la excepción de la forma en que lo hicimos, Spring necesita saber cómo lidiar con ella si se encuentra. Para eso, hemos creado un AppExceptionHandler que está anotado con @ControllerAdvice y tiene un @ExceptionHandler definido para FileStorageException:
@ControllerAdvice
public class AppExceptionHandler {
@ExceptionHandler(FileStorageException.class)
public ModelAndView handleException(FileStorageException exception, RedirectAttributes redirectAttributes) {
ModelAndView mav = new ModelAndView();
mav.addObject("message", exception.getMsg());
mav.setViewName("error");
return mav;
}
}
En el handleException método simplemente devolvimos el ModelAndView objeto que devolverá el error message en una vista de error, que es solo una plantilla de Thymeleaf llamada error.html:
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>ERROR</title>
</head>
<body>
<h1>Error!!!</h1>
<div th:if="${message}">
<h2 th:text="${message}"/>
</div>
</body>
</html>
Si desea leer más sobre las excepciones en Java y Spring, lo cubrimos en detalle en los siguientes artículos:
- Manejo de excepciones en Java: una guía completa con las mejores y las peores prácticas
- Cómo hacer excepciones personalizadas en Java
- Manejo de excepciones en Spring
Controlador y Frontend
Creemos ahora un sencillo FileController clase que usará el FileService para manejar la carga de archivos:
@Controller
public class FileController {
@Autowired
FileService fileService;
@GetMapping("/")
public String index() {
return "upload";
}
@PostMapping("/uploadFile")
public String uploadFile(@RequestParam("file") MultipartFile file, RedirectAttributes redirectAttributes) {
fileService.uploadFile(file);
redirectAttributes.addFlashAttribute("message",
"You successfully uploaded " + file.getOriginalFilename() + "!");
return "redirect:/";
}
}
Vamos a dividirlo línea por línea:
@ControllerLa anotación es también una especialización de@Componentanotación. Hace que una clase acepte la solicitud HTTP y responda en consecuencia. También se encarga de las diversas conversiones de la carga útil de la solicitud a una estructura de datos interna.- Luego, nosotros
@AutowiredlaFileServicefrijol para que podamos usar suuploadFilemétodo. - Entonces tenemos un simple
GetMappinga/que simplemente devolverá Stringupload. Al ser una clase de controlador, Spring buscaráupload.htmly sírvasela en el navegador. - A continuación, tenemos un
PostMappingde/uploadFile, que tienen unRequestParamdeMultipartFileque es un objeto que tiene nuestro archivo y sus detalles de metadatos. - Luego usamos el
FileServiceuploadFilemétodo para cargar el archivo.RedirectAttributeses una especialización de SpringModelinterfaz que se utiliza para seleccionar atributos para un escenario de redireccionamiento. - Si la operación anterior es exitosa, configuramos el mensaje de éxito en
redirectAttributesy redirigir a la misma página.
Ahora hagamos otra plantilla de Thymeleaf,upload.html:
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<body>
<h1>Spring Boot File Upload Example</h1>
<hr/>
<h4>Upload Single File:</h4>
<form method="POST" th:action="@{/uploadFile}" enctype="multipart/form-data">
<input type="file" name="file"/> <br/><br/>
<button type="submit">Submit</button>
</form>
<hr/>
<div th:if="${message}">
<h2 th:text="${message}"/>
</div>
</body>
</html>
Arriba, tenemos un sencillo form que se asigna al /uploadFile URL. Note que es enctype es multipart/form-data y input escribir como file. En la parte inferior tiene un mensaje div para mostrar el mensaje de éxito.
Nuestra clase principal es una clase principal típica de Spring Boot:
@SpringBootApplication
public class FileIoApplication {
public static void main(String[] args) {
SpringApplication.run(FileIoApplication.class, args);
}
}
Ejecutemos nuestra aplicación y naveguemos a http://localhost:8080:
Elija un archivo y cárguelo, debería ver algo como:
Carga de varios archivos
Del mismo modo, podemos escribir código para cargar varios archivos. Agregue el siguiente mapeo en FileController.java:
@PostMapping("/uploadFiles")
public String uploadFiles(@RequestParam("files") MultipartFile[] files, RedirectAttributes redirectAttributes) {
Arrays.asList(files)
.stream()
.forEach(file -> fileService.uploadFile(file));
redirectAttributes.addFlashAttribute("message",
"You successfully uploaded all files!");
return "redirect:/";
}
Como puede ver, el /uploadFiles El mapeo es similar al anterior, excepto que tiene un MultipartFile[] como argumento. Usamos la API de Java 8 Stream para cargar cada archivo en la matriz.
Al igual que antes, si la operación anterior es exitosa, configuramos el mensaje de éxito en redirectAttributes y redirigir a la misma página.
Ahora, solo necesitamos actualizar el código en la plantilla upload.html para manejar esto:
<h4>Upload Multiple Files:</h4>
<form method="POST" th:action="@{/uploadFiles}" enctype="multipart/form-data">
<input type="file" name="files" multiple/> <br/><br/>
<button type="submit">Submit</button>
</form>
<hr/>
Lo único diferente del HTML anterior es que el mapeo es al /uploadFiles punto final y el input tiene un multiple atributo, lo que le permite seleccionar más de un archivo. También desde el @RequestParam es files, tenemos que usar el mismo name en HTML.
Ejecutemos nuestra aplicación nuevamente y naveguemos a http://localhost:8080:
Elegir la segunda opción ahora nos permite seleccionar más de un archivo de nuestro sistema de archivos y cargarlos todos.
Limitar el tamaño del archivo
Puede ajustar los límites de carga de archivos utilizando spring.servlet.multipart.max-file-size y spring.servlet.multipart.max-request-size en application.properties:
spring.servlet.multipart.max-file-size = 5MB
spring.servlet.multipart.max-request-size = 5MB
Puedes establecer los límites en KB, MB, GBetc.
El valor predeterminado para spring.servlet.multipart.max-file-size es 1 MB y el valor predeterminado para spring.servlet.multipart.max-request-size es de 10 MB. Aumentando el límite para max-file-size Probablemente sea una buena idea ya que el valor predeterminado es muy bajo, pero tenga cuidado de no establecerlo demasiado alto, lo que podría sobrecargar su servidor.
Conclusión
En este artículo, hemos cubierto cómo cargar un solo archivo y varios archivos en una aplicación Spring Boot. Usamos Spring’s MultipartFile interfaz para capturar el archivo en la solicitud HTTP y las plantillas Thymeleaf como nuestro motor de renderizado.
Como siempre, el código de los ejemplos utilizados en este artículo se puede encontrar en GitHub.
