Métodos DELETE en controladores REST

Intermedio
SpringBoot
SpringBoot
Actualizado: 13/06/2025

¡Desbloquea el curso de SpringBoot completo!

IA
Ejercicios
Certificado
Entrar

Mira la lección en vídeo

Accede al vídeo completo de esta lección y a más contenido exclusivo con el Plan Plus.

Desbloquear Plan Plus

Borrado con DeleteMapping

La anotación @DeleteMapping permite crear endpoints REST que manejan peticiones HTTP DELETE para eliminar recursos del sistema. Esta anotación forma parte del conjunto de anotaciones especializadas de Spring que simplifican la creación de APIs REST siguiendo las convenciones del protocolo HTTP.

Configuración básica de DeleteMapping

Para implementar un endpoint de borrado, utilizamos @DeleteMapping junto con la ruta del recurso que queremos eliminar. La convención REST establece que las operaciones de borrado deben incluir el identificador del recurso en la URL:

@RestController
@RequestMapping("/api/usuarios")
public class UsuarioController {

    @Autowired
    private UsuarioService usuarioService;

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> eliminarUsuario(@PathVariable Long id) {
        usuarioService.eliminarPorId(id);
        return ResponseEntity.noContent().build();
    }
}

En este ejemplo, el endpoint responde a peticiones DELETE dirigidas a /api/usuarios/{id}, donde {id} representa el identificador único del usuario que se desea eliminar.

Códigos de respuesta HTTP apropiados

Las operaciones de borrado deben devolver códigos de estado HTTP que reflejen el resultado de la operación. Los más comunes son:

204 No Content - Indica que el recurso se eliminó correctamente:

@DeleteMapping("/{id}")
public ResponseEntity<Void> eliminarProducto(@PathVariable Long id) {
    productoService.eliminar(id);
    return ResponseEntity.noContent().build();
}

404 Not Found - Cuando el recurso no existe:

@DeleteMapping("/{id}")
public ResponseEntity<Void> eliminarCategoria(@PathVariable Long id) {
    boolean eliminado = categoriaService.eliminarSiExiste(id);
    
    if (eliminado) {
        return ResponseEntity.noContent().build();
    } else {
        return ResponseEntity.notFound().build();
    }
}

Validación antes del borrado

Es fundamental validar la existencia del recurso antes de intentar eliminarlo. Esto evita errores y proporciona respuestas más informativas al cliente:

@DeleteMapping("/{id}")
public ResponseEntity<String> eliminarPedido(@PathVariable Long id) {
    Optional<Pedido> pedido = pedidoService.buscarPorId(id);
    
    if (pedido.isEmpty()) {
        return ResponseEntity.notFound().build();
    }
    
    // Verificar si el pedido puede ser eliminado
    if (pedido.get().getEstado().equals("PROCESADO")) {
        return ResponseEntity.badRequest()
            .body("No se puede eliminar un pedido ya procesado");
    }
    
    pedidoService.eliminar(id);
    return ResponseEntity.noContent().build();
}

Borrado con confirmación mediante parámetros

En algunos casos, es útil requerir confirmación explícita para operaciones de borrado críticas:

@DeleteMapping("/{id}")
public ResponseEntity<String> eliminarCuenta(
        @PathVariable Long id,
        @RequestParam(required = true) boolean confirmar) {
    
    if (!confirmar) {
        return ResponseEntity.badRequest()
            .body("Debe confirmar la eliminación de la cuenta");
    }
    
    cuentaService.eliminarDefinitivamente(id);
    return ResponseEntity.noContent().build();
}

Borrado lógico vs físico

Guarda tu progreso

Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.

Progreso guardado
Asistente IA
Ejercicios
Iniciar sesión gratis

Más de 25.000 desarrolladores ya confían en CertiDevs

Muchas aplicaciones implementan borrado lógico en lugar de eliminar físicamente los registros de la base de datos:

@DeleteMapping("/{id}")
public ResponseEntity<Void> desactivarUsuario(@PathVariable Long id) {
    usuarioService.marcarComoEliminado(id);
    return ResponseEntity.noContent().build();
}

@DeleteMapping("/{id}/permanente")
public ResponseEntity<Void> eliminarUsuarioPermanente(@PathVariable Long id) {
    usuarioService.eliminarFisicamente(id);
    return ResponseEntity.noContent().build();
}

Manejo de errores en operaciones de borrado

Las operaciones de borrado pueden fallar por diversas razones. Es importante capturar estas situaciones y devolver respuestas apropiadas:

@DeleteMapping("/{id}")
public ResponseEntity<String> eliminarDocumento(@PathVariable Long id) {
    try {
        documentoService.eliminar(id);
        return ResponseEntity.noContent().build();
    } catch (DocumentoEnUsoException e) {
        return ResponseEntity.status(HttpStatus.CONFLICT)
            .body("El documento no puede eliminarse porque está siendo utilizado");
    } catch (DocumentoNoEncontradoException e) {
        return ResponseEntity.notFound().build();
    } catch (Exception e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body("Error interno del servidor");
    }
}

Borrado en lote

Para eliminar múltiples recursos de una vez, podemos aceptar una lista de identificadores:

@DeleteMapping("/lote")
public ResponseEntity<Map<String, Object>> eliminarVariosProductos(
        @RequestBody List<Long> ids) {
    
    List<Long> eliminados = new ArrayList<>();
    List<Long> noEncontrados = new ArrayList<>();
    
    for (Long id : ids) {
        if (productoService.existe(id)) {
            productoService.eliminar(id);
            eliminados.add(id);
        } else {
            noEncontrados.add(id);
        }
    }
    
    Map<String, Object> resultado = Map.of(
        "eliminados", eliminados,
        "noEncontrados", noEncontrados
    );
    
    return ResponseEntity.ok(resultado);
}

La implementación de endpoints de borrado con @DeleteMapping requiere considerar aspectos como la validación de datos, el manejo de errores y la elección de códigos de respuesta HTTP apropiados para crear APIs REST robustas y predecibles.

Aprendizajes de esta lección de SpringBoot

  • Comprender el uso de la anotación @DeleteMapping para crear endpoints REST que manejan peticiones DELETE.
  • Aprender a validar la existencia de recursos antes de su eliminación.
  • Conocer los códigos de estado HTTP apropiados para operaciones de borrado.
  • Implementar manejo de errores y confirmaciones en operaciones DELETE.
  • Diferenciar entre borrado lógico y físico, y gestionar borrados en lote.

Completa este curso de SpringBoot y certifícate

Únete a nuestra plataforma de cursos de programación y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.

Asistente IA

Resuelve dudas al instante

Ejercicios

Practica con proyectos reales

Certificados

Valida tus conocimientos

Más de 25.000 desarrolladores ya se han certificado con CertiDevs

⭐⭐⭐⭐⭐
4.9/5 valoración