Un endpoint para subir imágenes y PDF y otro para descargarlos, con los límites y las revisiones que separan un ejemplo de juguete de uno que puedes poner en internet.
También te puede interesar
Lo que necesitas
Solo Spring Web. Los archivos llegan en peticiones multipart/form-data, el formato que usan los formularios web con un campo de archivo, y Spring los entrega como MultipartFile. Primero, los límites y la carpeta donde se guardan:
spring.application.name=archivos spring.servlet.multipart.max-file-size=1MB spring.servlet.multipart.max-request-size=1MB spring.mvc.problemdetails.enabled=true archivos.carpeta=/tmp/subidas
Spring Boot acepta por omisión archivos de hasta 1 MB y peticiones de hasta 10 MB; aquí bajamos las dos a 1 MB. Fíjate en que la carpeta es configurable: en un servidor, apúntala a un disco con espacio y respaldos, nunca a la carpeta de la aplicación.
El controlador
package com.ejemplo.archivos;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.PathResource;
import org.springframework.core.io.Resource;
import org.springframework.http.ContentDisposition;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.server.ResponseStatusException;
@RestController
@RequestMapping("/archivos")
public class ArchivoController {
private static final Set<String> PERMITIDOS = Set.of("image/png", "image/jpeg", "application/pdf");
private final Path carpeta;
public ArchivoController(@Value("${archivos.carpeta}") Path carpeta) throws IOException {
this.carpeta = Files.createDirectories(carpeta);
}
@PostMapping
public ResponseEntity<Map<String, Object>> subir(@RequestParam MultipartFile archivo) throws IOException {
if (archivo.isEmpty() || !PERMITIDOS.contains(archivo.getContentType())) {
throw new ResponseStatusException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "Solo se aceptan PNG, JPEG o PDF");
}
String extension = switch (archivo.getContentType()) {
case "image/png" -> ".png";
case "image/jpeg" -> ".jpg";
default -> ".pdf";
};
String nombre = UUID.randomUUID() + extension; // nunca el nombre que manda el cliente
archivo.transferTo(carpeta.resolve(nombre));
return ResponseEntity.status(HttpStatus.CREATED).body(Map.of(
"nombre", nombre, "original", String.valueOf(archivo.getOriginalFilename()), "bytes", archivo.getSize()));
}
@GetMapping("/{nombre}")
public ResponseEntity<Resource> bajar(@PathVariable String nombre) throws IOException {
Path ruta = carpeta.resolve(nombre).normalize();
if (!ruta.startsWith(carpeta) || !Files.isRegularFile(ruta)) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "No existe el archivo");
}
return ResponseEntity.ok()
.contentType(MediaType.parseMediaType(Files.probeContentType(ruta) == null
? "application/octet-stream" : Files.probeContentType(ruta)))
.header(HttpHeaders.CONTENT_DISPOSITION, ContentDisposition.attachment().filename(nombre).build().toString())
.body(new PathResource(ruta));
}
}Tres decisiones de seguridad que no son opcionales:
- Lista de tipos permitidos. Se rechaza todo lo que no sea PNG, JPEG o PDF. El tipo lo declara el cliente, así que es una primera barrera, no una garantía; si el archivo se va a mostrar o procesar, revisa también su contenido.
- Nombre propio. Se guarda con un UUID al azar, nunca con el nombre que mandó el cliente, que podría ser
../../index.htmlo pisar el archivo de otra persona. El nombre original se guarda solo como dato. - Revisar la ruta al bajar.
normalize()resuelve los..ystartsWith(carpeta)comprueba que la ruta siga dentro de la carpeta permitida. Es la defensa contra el path traversal.
Probarlo
Con curl, -F "archivo=@logo.png" manda el archivo como lo haría un formulario. Subimos una imagen, la bajamos y comprobamos que llegó idéntica; después, un tipo no permitido, uno demasiado grande y un intento de salir de la carpeta:
terminal$ curl -s -F "archivo=@logo.png;type=image/png" localhost:8080/archivos | jq -c
{"original":"logo.png","bytes":2008,"nombre":"01257b9b-906f-4778-8d4f-6e13cf4a3250.png"}
$ curl -s -o copia.png -w "%{http_code} %{content_type}\n" localhost:8080/archivos/$NOMBRE
200 image/png
$ cmp logo.png copia.png && echo "son idénticos"
son idénticos
$ echo "no soy imagen" > nota.txt && curl -s -F "archivo=@nota.txt;type=text/plain" localhost:8080/archivos | jq -c
{"detail":"Solo se aceptan PNG, JPEG o PDF","status":415,"title":"Unsupported Media Type"}
$ head -c 2000000 /dev/zero > grande.pdf && curl -s -F "archivo=@grande.pdf;type=application/pdf" localhost:8080/archivos | jq -c
{"detail":"Maximum upload size exceeded","status":413,"title":"Content Too Large"}
$ curl -s -o /dev/null -w "%{http_code}\n" "localhost:8080/archivos/..%2F..%2Fetc%2Fpasswd"
400El texto se rechazó con 415; el PDF de 2 MB, con 413 Content Too Large, que Spring responde solo gracias al límite de application.properties, sin que tu método llegue a ejecutarse. Y el intento de leer /etc/passwd con diagonales codificadas (%2F) ni siquiera llegó a Spring: Tomcat rechaza esas diagonales de fábrica con un 400. La revisión de startsWith en el controlador es la segunda capa, para el día en que el nombre llegue por otro camino, como un parámetro o un dato de la base. Para guardar los datos de cada archivo (quién lo subió, cuándo, el nombre original), usa una tabla como en el CRUD; los bytes, en el disco o en un servicio de almacenamiento como S3.
Cada proyecto de esta página se compiló con Spring Boot 4.2.0, Java 25 (Temurin 25.0.5.1) y Maven 3.10.1 en un contenedor limpio y sin red, se arrancó y se probó con las peticiones de curl que ves; las respuestas y los registros están copiados de esa ejecución.