Controlar las respuestas HTTP

Desde la versión 5 de Spring existe el siguiente método static en ResponseEntity.

ResponseEntity.of(productService.getProduct(productId))

Uno puede usar la anterior línea como alternativa a las líneas 26, 27 y 28.

En el método delete, si no quieren usar if y else, también pueden usar el operador ternario:

@DeleteMapping("/delete/{id}")
public ResponseEntity delete(@PathVariable("id") int productId) {
    return new ResponseEntity(this.productService.delete(productId)
            ? HttpStatus.OK
            : HttpStatus.NOT_FOUND);
}

Una observacion, cuando se consulta a la base de datos y se desea obtener una lista de producto por categoria y la categoria no existe entonces se devuelve una lista vacía, entonces, al hacer el map or else nunca entra al or else porque En el Optional si está presenta la lista, solo que está vacía, entonces aunque la categoria no exista siempre devolverá estatus OK -> 200.

Yo lo hice asi:

    @GetMapping("/category/{id}")
    public ResponseEntity<List<Product>> getByCategory(@PathVariable("id") int categoryId){
    	
    	List<Product> products = productService.getByCategory(categoryId).orElse(null);
    	
        return products != null && !products.isEmpty() ?
        				new ResponseEntity<>(products, HttpStatus.OK)
        				: new ResponseEntity<List<Product>>(HttpStatus.NOT_FOUND);
    }

porque un not found en vez de un no content???

Me funcionan todos los métodos excepto el getByCategory, cuando no encuentra los productos de una categoría retorna Status 200 OK.
Aquí dejo el código:

	@GetMapping("/category/{categoryId}")
	public ResponseEntity<List<Product>> getByCategory(@PathVariable("categoryId") int categoryId){
		return productService.getByCategory(categoryId)
				.map(products -> new ResponseEntity<>(products,HttpStatus.OK))
				.orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));
	}```

Esta fue mi forma para hacer el delete, por si a alguien le ayuda

@DeleteMapping("/{productId}")
    public ResponseEntity<Void> delete(@PathVariable int productId) {
        boolean deleted = productService.delete(productId);
        return deleted ? ResponseEntity.ok().build() : ResponseEntity.notFound().build();
    }

Justo hice una consulta en la clase anterior, pero después de terminar la clase me parece que tiene mucho sentido diferenciar la creación de la actualización del producto.

 @PutMapping()
    public ResponseEntity<Product> create(@RequestBody Product product) {
        return new ResponseEntity<>(productService.save(product), HttpStatus.CREATED);
    }

    @PostMapping()
    public ResponseEntity<Product> update(@RequestBody Product product) {
        return new ResponseEntity<>(productService.save(product), HttpStatus.OK);
    }

ResponseEntity esta muy completo y puedes usarlo de varias formas, explora escribiendo ResponseEntity. + ctrl

return ResponseEntity.of(Optional.ofNullable(productService.getAll()));
        
return ResponseEntity.ok().body(productService.getAll());
        
return ResponseEntity.status(HttpStatus.OK).body(productService.getAll());
        
return new ResponseEntity<>(productService.getAll(), HttpStatus.OK);

En lo personal me gusta más esta ya que te responde un HttpStatus y el body

return ResponseEntity.status(HttpStatus.OK).body(productService.getAll());

Es una de las mejores clases porque empiezo en Spring, anteriormente hice un proyecto básico, pero no incluía las ResponseEntity, si que son muy utiles!

Una forma un poco más elegante de definir el delete:

@DeleteMapping("/{id}")
public ResponseEntity delete(@PathVariable("id") int productId) {
    return productService.delete(productId) ?
            new ResponseEntity<>(HttpStatus.NO_CONTENT) :
            new ResponseEntity<>(HttpStatus.NOT_FOUND);
}

¿Alguien ha notado que cuando se hace un request que devuelve una lista y esta no tiene elementos, igual devuelve status 200?

Por ejemplo si haces un request a /products/category/583 (la categoría 583 no existe) igual devuelve status 200 y debería devolver 404

Las peticiones en spring cómo funcionan? cada petición es única y se atiende de forma personalizada, pero Spring puede atender múltiples de peticiones únicas al mismo tiempo ?, espero pueda darme a entender

Recurso

El delete:

 @DeleteMapping("/{productId}")
    public ResponseEntity delete(@PathVariable int productId){
        return productService.delete(productId)
                ? new ResponseEntity(HttpStatus.OK)
                : new ResponseEntity(HttpStatus.NOT_FOUND);
    }

Me parece interesante ver cómo se va construyendo todo. Comienza con unos pocos elementos y ya llega hasta acá.

les envio el de lista de productos por categoria con lambda
return new ResponseEntity<>(productService.getByCategory(categoryId).orElseGet(ArrayList::new), HttpStatus.OK);

les envio el de getProduct con lambda
@GetMapping("/{productId}")
public ResponseEntity<Product> getProduct(@PathVariable(“productId”) BigDecimal productId) {
return new ResponseEntity<>(productService.getProduct(productId).orElseGet(Product::new), HttpStatus.OK);
}

Si la funcion getByCategory en Postman devuelve una lista vacia puede ser porque (al igual que yo) tenias un codigo en el repository tal que:

@Override
    public Optional<List<Product>> getByCategory(int categoryId) {
        List<Producto> productos = productoCrudRepository.findByIdCategoriaOrderByNombreAsc(categoryId);
        return Optional.of(mapper.toProducts(productos));
    }

Lo que hace el Optional.of es que crea un Optional con una lista y si no hay productos será una lista vacía no un Optional vacío que es lo que buscamos, para eso se podría hacer con Optional.empty(), dejando el codigo asi:

@Override
public Optional<List<Product>> getByCategory(int categoryId) {
List<Producto> productos = productoCrudRepository.findByIdCategoriaOrderByNombreAsc(categoryId);
if (productos.isEmpty()) {
return Optional.empty();
} else {
return Optional.of(mapper.toProducts(productos));
}
}

Ahora si devuelve un error 404 not found

Podemos usar operadores condicionales ternarios en el delete

@DeleteMapping("{id}")
    public ResponseEntity delete (@PathVariable("id") int productId) {
        return productService.delete(productId) ? 
								new ResponseEntity(HttpStatus.OK) :
								new ResponseEntity(HttpStatus.NOT_FOUND);
    }```

De esta manera puede quedar algo mas limpio el delete.

@DeleteMapping("/delete/{id}")
    public ResponseEntity delete(@PathVariable("id") int id){
        ResponseEntity response = productService.delete(id) ? ResponseEntity.ok().build() : ResponseEntity.notFound().build();
        return  response;
    }

Para el endpoint DELETE se puede evitar el condicional ELSE.

Si se cumple la condición, se retornará OK, si no se cumple, se retornará NOT_FOUND sin problemas.

if (productService.delete(productId)) return new ResponseEntity<>(HttpStatus.OK);
return new ResponseEntity<>(HttpStatus.NOT_FOUND);

Yo cree el metodo para actualizar pero aún no estoy muy convencido de si esta bien. Me podrían dar feedback

@PutMapping(value = "/update/{productId}")
public ResponseEntity<Product> update(@PathVariable("productId") long productId, @RequestBody Product product){
    if (productService.getProduct(productId) == null){
        return new ResponseEntity<>(HttpStatus.NOT_FOUND);
    }else{
        return new ResponseEntity<>(productService.update(product), HttpStatus.OK);
    }
}