Controlul complet al răspunsului cu ResponseEntity
Până acum Spring a ales singur codul de status: 200 pentru orice metodă care întoarce ceva. Dar ce faci când produsul cerut nu există? Cu ResponseEntity alegi tu codul, corpul și antetele răspunsului. Înveți ok, notFound, badRequest, status și un mod elegant de a întoarce 404 cu Optional.
Problema: 200 pentru orice
O metodă care întoarce Produs răspunde mereu cu 200. Dacă id-ul nu există, ce întorci? null ar da un 200 cu corp gol, iar clientul ar crede că totul e în regulă. Corect este 404 Not Found: „resursa cerută nu există”.
ResponseEntity<T> (din pachetul org.springframework.http) este tot răspunsul: codul de status, antetele și corpul de tip T. Când metoda întoarce un ResponseEntity, Spring trimite exact ce ai construit.
Metodele de construcție
| Cod | Ce scrii | Când |
|---|---|---|
| 200 | ResponseEntity.ok(corp) | totul a mers |
| 404 | ResponseEntity.notFound().build() | resursa nu există (fără corp) |
| 400 | ResponseEntity.badRequest().body(corp) | clientul a trimis date greșite |
| oricare | ResponseEntity.status(HttpStatus.X).body(corp) | orice alt cod, cu sau fără corp |
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@RestController
class StocController {
@GetMapping("/stoc/{cod}")
ResponseEntity<String> stoc(@PathVariable String cod) {
if (cod.equals("A1")) {
return ResponseEntity.ok("Mai sunt 12 bucăți");
}
if (cod.length() != 2) {
return ResponseEntity.badRequest().body("Codul are două caractere, de exemplu A1");
}
return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Nu există produsul " + cod);
}
}
// > GET /stoc/A1
// > GET /stoc/ABC
// > GET /stoc/B7Tomcat started on port 8080 (http) Started Application GET /stoc/A1 → 200 Mai sunt 12 bucăți GET /stoc/ABC → 400 Codul are două caractere, de exemplu A1 GET /stoc/B7 → 404 Nu există produsul B7
<String> din ResponseEntity<String> spune tipul corpului. HttpStatus are câte o constantă pentru fiecare cod: OK, NOT_FOUND, BAD_REQUEST, CREATED și celelalte. Corpul poate fi și un text explicativ, cum vezi la 400 și 404.
404 fără corp
Cel mai des, ResponseEntity apare la „caută după id”: dacă găsești, ok(obiect); dacă nu, notFound().build(). build() termină răspunsul fără corp, deci laboratorul arată doar linia de status:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
record Curs(long id, String titlu) { }
@RestController
class CursController {
private final List<Curs> cursuri = List.of(new Curs(1, "Java"), new Curs(2, "Spring Boot"));
@GetMapping("/cursuri/{id}")
ResponseEntity<Curs> curs(@PathVariable long id) {
for (Curs c : cursuri) {
if (c.id() == id) {
return ResponseEntity.ok(c);
}
}
return ResponseEntity.notFound().build();
}
}
// > GET /cursuri/2
// > GET /cursuri/7Tomcat started on port 8080 (http)
Started Application
GET /cursuri/2 → 200
{"id":2,"titlu":"Spring Boot"}
GET /cursuri/7 → 404Când întorci tu notFound().build(), Spring nu mai adaugă JSON-ul lui de eroare (status, error, path): ai decis tu răspunsul. Pentru un 404 fără explicații e perfect; pentru erori cu mesaje vei folosi mai târziu ProblemDetail și handler-e de excepții.
Optional: 404 elegant
Căutarea într-o listă se poate scrie scurt cu un stream: filter păstrează elementele potrivite, iar findFirst() întoarce un Optional, gol dacă nu a găsit nimic. Pe un Optional, map transformă valoarea (dacă există), iar orElse dă alternativa:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
record Curs(long id, String titlu) { }
@RestController
class CursController {
private final List<Curs> cursuri = List.of(new Curs(1, "Java"), new Curs(2, "Spring Boot"));
Optional<Curs> cauta(long id) {
return cursuri.stream().filter(c -> c.id() == id).findFirst();
}
@GetMapping("/cursuri/{id}")
ResponseEntity<Curs> curs(@PathVariable long id) {
return cauta(id)
.map(c -> ResponseEntity.ok(c))
.orElse(ResponseEntity.notFound().build());
}
@GetMapping("/cursuri/{id}/titlu")
String titlu(@PathVariable long id) {
return cauta(id).map(Curs::titlu).orElse("necunoscut");
}
}
// > GET /cursuri/1
// > GET /cursuri/5
// > GET /cursuri/5/titluTomcat started on port 8080 (http)
Started Application
GET /cursuri/1 → 200
{"id":1,"titlu":"Java"}
GET /cursuri/5 → 404
GET /cursuri/5/titlu → 200
necunoscutCând folosești ResponseEntity
- Întoarce direct obiectul când răspunsul este mereu 200 (o listă, statistici): codul e mai scurt și mai clar.
- **Folosește ResponseEntity** când codul depinde de situație (200 sau 404), când vrei alt cod decât 200 (201, 204) sau când adaugi antete.
- În echipele reale vei vedea ambele stiluri, uneori în același controller. Important este să răspunzi cu codul corect.
| Situație reală | Răspuns |
|---|---|
| comanda 2031 există | 200 cu comanda |
| comanda 2031 nu există sau e a altui client | 404 |
| clientul trimite o cantitate negativă | 400 cu explicația |
Greșeli frecvente
- **Întorci null** pentru o resursă inexistentă: clientul primește 200 cu corp gol. Folosește 404.
- **Uiți build()** după notFound(): notFound() singur nu este încă un răspuns și nu compilează ca ResponseEntity.
- Uiți importul org.springframework.http.ResponseEntity (și HttpStatus când îl folosești).
- Tipul generic greșit: ResponseEntity<Produs> trebuie să aibă corp Produs; pentru texte folosește ResponseEntity<String>.
Pe scurt
- ResponseEntity<T> este tot răspunsul: status, antete, corp.
- ok(corp), notFound().build(), badRequest().body(...), status(HttpStatus.X).body(...).
- Pentru „caută după id”: optional.map(x -> ResponseEntity.ok(x)).orElse(ResponseEntity.notFound().build()).
- Întoarce direct obiectul când răspunsul este mereu 200; folosește ResponseEntity când codul variază.
Acum GET /produse/{id} întoarce mereu primul produs, chiar și pentru id-uri care nu există. Repar-o: metoda întoarce ResponseEntity<Produs>, cu 200 și produsul dacă id-ul există, sau 404 fără corp dacă nu. Laboratorul trimite /produse/1 și /produse/99.
- Schimbă tipul întors al metodei în ResponseEntity<Produs>.
- Caută produsul cu id-ul cerut (cu o buclă sau cu stream().filter(...).findFirst()).
- Dacă îl găsești, întoarce ResponseEntity.ok(produs); altfel ResponseEntity.notFound().build().
Soluția exercițiului
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
record Produs(long id, String nume, double pret) { }
@RestController
class ProdusController {
private final List<Produs> produse = List.of(
new Produs(1, "Laptop", 3500.0),
new Produs(2, "Mouse", 99.5)
);
@GetMapping("/produse/{id}")
ResponseEntity<Produs> produs(@PathVariable long id) {
return produse.stream()
.filter(p -> p.id() == id)
.findFirst()
.map(p -> ResponseEntity.ok(p))
.orElse(ResponseEntity.notFound().build());
}
} 