No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Aprende Ingl茅s, Programaci贸n, AI, Ciberseguridad y mucho m谩s.

Antes: $249

Currency
$209
Suscr铆bete

Termina en:

3 D铆as
6 Hrs
46 Min
29 Seg
Curso de Java Spring

Curso de Java Spring

Alejandro Ram铆rez

Alejandro Ram铆rez

Controlar las respuestas HTTP

26/35
Recursos

Aportes 26

Preguntas 13

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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.

HttpStatus with cat
https://http.cat/

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());
@GetMapping no debe responder con NOT\_FOUD ya que es confuso, el cliente puede pensar que /{id} no existe y est谩 llamando al endpoint incorrecto, para esto est谩 NO\_CONTENT que indica que si se encuentra el recurso /{id} pero no hay un producto con el id proporcionado

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

* ` @GetMapping("/{id}") public ResponseEntity getProducto(@PathVariable Long id){ Map<String,Object> data = new HashMap<>(); if(productoService.getProduct(id).isPresent()){ data.put("data", productoService.getProduct(id)); return ResponseEntity.ok(data); } return ResponseEntity.status(HttpStatus.NOT_FOUND).body("No se encontro el id"); }`
@GetMapping("/{id}") public ResponseEntity\ getProducto(@PathVariable Long id){ Map\<String,Object> data = new HashMap<>(); if(productoService.getProduct(id).isPresent()){ data.put("data", productoService.getProduct(id)); return ResponseEntity.ok(data); } return ResponseEntity.status(HttpStatus.NOT\_FOUND).body("No se encontro el id"); }

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(鈥減roductId鈥) 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);
    }
}