...
← Curs Spring Boot și REST API: toate lecțiile
Lecția 12 · Răspunsuri

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

CodCe scriiCând
200ResponseEntity.ok(corp)totul a mers
404ResponseEntity.notFound().build()resursa nu există (fără corp)
400ResponseEntity.badRequest().body(corp)clientul a trimis date greșite
oricareResponseEntity.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/B7
Tomcat 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/7
Tomcat started on port 8080 (http)
Started Application
GET /cursuri/2 → 200
{"id":2,"titlu":"Spring Boot"}
GET /cursuri/7 → 404
Corp gol, nu JSON de eroare

Câ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/titlu
Tomcat started on port 8080 (http)
Started Application
GET /cursuri/1 → 200
{"id":1,"titlu":"Java"}
GET /cursuri/5 → 404
GET /cursuri/5/titlu → 200
necunoscut
1
cauta(id) întoarce Optional<Curs>: plin pentru id-ul 1, gol pentru 5.
2
.map(c -> ResponseEntity.ok(c)) transformă cursul găsit într-un răspuns 200.
3
.orElse(ResponseEntity.notFound().build()) dă răspunsul 404 când Optional-ul e gol.
4
Aceeași metodă cauta servește și ruta /titlu, care folosește orElse("necunoscut") în loc de 404.

Câ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 client404
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ă.
Exercițiul tău

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().
produse.stream().filter(p -> p.id() == id).findFirst().map(p -> ResponseEntity.ok(p)).orElse(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());
    }
}
Excelent! Continuă cu lecția următoare →
Application.javaSpring Boot
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Primul tău API cu Spring Boot Lecția 12 · Controlul complet al răspunsului cu ResponseEntity
Progres 0% 0 din 20
Lecția curentă 12 / 18 Răspunsuri