Creación de endpoint PUT para actualizar películas en base de datos

Clase 17 de 23 • Curso de Java Spring Boot

Resumen

Actualizar información en una base de datos es esencial para gestionar aplicaciones modernas de manera segura. En este resumen aprenderás cómo implementar de forma controlada y eficiente un endpoint PUT para modificar solo campos permitidos de una película, usando buenas prácticas y herramientas propias del desarrollo backend.

¿Cómo controlar qué campos pueden modificarse con un endpoint PUT?

Permitir la edición parcial evita errores y mantiene la integridad de los datos. Se recomienda crear un UpdateMovieDTO exclusivo para las actualizaciones, que incluya únicamente los campos editables como título, fecha de lanzamiento y calificación (rating).

El ID y otros valores sensibles como género o duración quedan excluidos del UpdateMovieDTO.
Usar DTOs separados promueve la seguridad y claridad en la lógica de actualización.
Copiar la estructura de MovieDTO y modificar los campos según lo necesario facilita la implementación.

¿Cómo diseñar el controlador para recibir las actualizaciones?

La anotación @PutMapping se utiliza para recibir el ID de la película como parte de la URL, y el cuerpo del request incluye el UpdateMovieDTO.

El ID se captura con la anotación @PathVariable.
El método controlador recibe ambos valores para identificar correctamente el registro y su información a modificar.
Esta separación asegura que la actualización se realice sobre la entidad correcta y con datos controlados.

¿Cómo validar la existencia y actualizar los datos en la base de datos?

Es fundamental comprobar que el registro existe antes de intentar cualquier cambio.

Utiliza el repositorio para buscar la entidad por ID con findById.
Si no existe, retorna null: así evitas intentos de modificar datos inexistentes.
Si existe, solo se asignan los nuevos valores permitidos con los métodos set correspondientes (título, release date y rating).
Se recomienda realizar conversiones de tipos, por ejemplo, de double a BigDecimal usando BigDecimal.valueOf si es necesario.

¿Cómo automatizar la asignación de valores con Mapstruct y MappingTarget?

Para simplificar y hacer más seguro el mapeo entre el DTO y la entidad, Mapstruct permite crear un método especial:

Define un método en el MovieMapper llamado updateEntityFromDTO que recibe el UpdateMovieDTO y la entidad a modificar.
Agrega la anotación @MappingTarget al segundo parámetro para aplicar los cambios por referencia.
Usa la notación @Mapping para señalar qué campos mapea cada vez (target y source).
Este método no retorna valor (void), ya que modifica directamente la instancia recibida.

¿Cómo integrar el flujo en el servicio y controlador?

El método update en el servicio centraliza la lógica:

Recibe el ID y UpdateMovieDTO.
Llama al repositorio para validar la existencia y actualizar solo los campos permitidos.
El controlador responde con ResponseEntity.ok llamando al servicio de actualización.
Las pruebas se pueden realizar con Postman enviando una petición PUT a la URL correspondiente, verificando la actualización correcta solo de los campos seleccionados.

¿Qué retos adicionales pueden implementarse para gestionar recursos?

Como ejercicio recomendable, se propone crear un servicio que permita eliminar películas utilizando la anotación @DeleteMapping y el ID del recurso. Esto completa el ciclo de gestión CRUD y fortalece la API.

Si tienes una solución diferente o quieres compartir resultados, la sección de comentarios está abierta para tus aportaciones y preguntas.

David Mauricio Gorraiz Moreno

student•

Primero agregue el metodo para borrar en MovieRepository:

package com.platzi.play.domain.repository;

import com.platzi.play.domain.dto.MovieDto;
import com.platzi.play.domain.dto.UpdateMovieDto;

import java.util.List;

public interface MovieRepository {
    List<MovieDto> getAll();
    MovieDto getById(Long id);
    MovieDto save(MovieDto movieDto);
    MovieDto update(long id, UpdateMovieDto updateMovieDto);
    MovieDto delete(long id);
}
```Luego agregue su funcionamiento en la clase MovieEntityRepository:

```java
@Override
    public MovieDto delete(long id) {
        MovieEntity movieEntity = this.crudMovieEntity.findById(id).orElse(null);

        if (movieEntity == null) return null;

        this.crudMovieEntity.delete(movieEntity);

        return this.movieMapper.toDto(movieEntity);
    }
```Luego en MovieService cree el metodo que se usara en el controller posteriormente:

```java
public MovieDto delete(long id){
        return this.movieRepository.delete(id);
    }
```Finalmente implemente este metodo del service en el MovieController:

```java
@DeleteMapping("/{id}")
    public ResponseEntity<MovieDto> delete(@PathVariable long id){
        return ResponseEntity.ok(this.movieService.delete(id));
    }

Salome Arboleda

student•

Mi solución:

--------------------------- MovieController ---------------------------

@DeleteMapping("/{id}")

public ResponseEntity<String> deleteById(@PathVariable long id) {

movieService.deleteById(id);

return ResponseEntity.ok("Movie with ID " + id + " was deleted successfully.");

}

--------------------------- MovieRepository ---------------------------

void deleteById(long id);

--------------------------- MovieEntityRepository ---------------------------

@Override

public void deleteById(long id) {

crudMovieEntity.findById(id)

.ifPresent(crudMovieEntity::delete);

}

--------------------------- MovieService ---------------------------

public void deleteById(long id) {

this.movieRepository.deleteById(id);

}

Xavier Armando Larios Alvarenga

student•

Comparto mi solución, pero hice un borrado lógico, para no perder información de la entidad:

//Solicitud HTTP en Postman
{
    "status": "D" // o "I" para INACTIVE
}

//Creación de Record para manejar el estado
package com.platzi.play.domain.dto;

public record LogicDeleteDTO(String status) {}

//MovieRepository
MovieDTO deleteLogic(long id, LogicDeleteDTO logicDeleteDTO);

//MovieMapper
@Mapping(target = "estado", source = "status")
void updateEntityStatus(LogicDeleteDTO logicDeleteDTO, @MappingTarget MovieEntity movieEntity);

//MovieEntityRepository
public MovieDTO deleteLogic(long id, LogicDeleteDTO logicDeleteDTO) {
MovieEntity movieEntity = crudMovieEntity.findById(id).orElse(null);

if (movieEntity == null) return null;

  this.movieMapper.updateEntityStatus(logicDeleteDTO, movieEntity);
return this.movieMapper.toDto(this.crudMovieEntity.save(movieEntity));}

//MovieController
@PutMapping("change-status/{id}")
public ResponseEntity<MovieDTO> deleteMovieLogic(@PathVariable long id, @RequestBody LogicDeleteDTO logicDeleteDTO) {
return ResponseEntity.ok(this.movieService.deleteLogic(id, logicDeleteDTO));}

Me gustaría saber si estoy utilizando la lógica adecuada o incluso el StatusMapper de forma correcta.