Date trimise de client: POST și @RequestBody
Până acum serverul doar a răspuns. Acum clientul îi trimite date: un produs nou, o comandă, un mesaj. Datele vin ca JSON în corpul cererii POST, iar @RequestBody le transformă într-un obiect Java. La final ții datele într-o listă în memorie, cu id-uri generate automat.
POST: cererea care trimite date
O cerere POST are un corp (body): date pe care clientul le trimite serverului, de obicei JSON. Când completezi un formular de comandă și apeși „Trimite”, aplicația face ceva de felul acesta:
POST /comenzi HTTP/1.1
Content-Type: application/json
{"produs": "Mouse", "cantitate": 2}Antetul Content-Type: application/json spune că acel corp este JSON. Cu curl ai scrie: curl -X POST localhost:8080/comenzi -H "Content-Type: application/json" -d '{"produs":"Mouse","cantitate":2}'. În laborator, adaugi corpul după cale în comentariu: // > POST /comenzi {"produs": "Mouse"}.
@RequestBody: JSON-ul devine obiect
@PostMapping leagă metoda de cererile POST. @RequestBody pe un parametru îi spune lui Spring: „citește corpul cererii și construiește din el un obiect de acest tip”. Jackson face drumul invers față de lecția 8: din JSON în record.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
record Mesaj(String autor, String text) { }
@RestController
class MesajController {
@PostMapping("/mesaje")
String trimite(@RequestBody Mesaj mesaj) {
return mesaj.autor() + " a scris: " + mesaj.text();
}
}
// > POST /mesaje {"autor": "Ana", "text": "Salut tuturor!"}Tomcat started on port 8080 (http) Started Application POST /mesaje → 200 Ana a scris: Salut tuturor!
Cheile din JSON (autor, text) se potrivesc cu numele componentelor record-ului. Metoda primește un Mesaj gata construit și lucrează cu el ca cu orice obiect Java.
Câmpuri lipsă, câmpuri în plus, JSON greșit
/* application.properties
server.error.include-message=always
*/
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
record Comanda(String produs, int cantitate, String observatii) { }
@RestController
class ComandaController {
@PostMapping("/comenzi")
Comanda plaseaza(@RequestBody Comanda comanda) {
return comanda;
}
}
// > POST /comenzi {"produs": "Mouse", "cantitate": 2, "observatii": "la poartă"}
// > POST /comenzi {"produs": "Cablu"}
// > POST /comenzi {"produs": "Monitor", "cantitate": 1, "culoare": "negru"}
// > POST /comenzi {"produs": "Monitor", "cantitate": }Tomcat started on port 8080 (http)
Started Application
POST /comenzi → 200
{"produs":"Mouse","cantitate":2,"observatii":"la poartă"}
POST /comenzi → 200
{"produs":"Cablu","cantitate":0,"observatii":null}
POST /comenzi → 200
{"produs":"Monitor","cantitate":1,"observatii":null}
POST /comenzi → 400
{"status":400,"error":"Bad Request","message":"JSON parse error: Unrecognized token '}' at position 35","path":"/comenzi"}- Cererea 1: toate câmpurile există, obiectul se construiește complet.
- Cererea 2: lipsesc cantitate și observatii. Componenta int primește 0, iar String-ul primește null. Spring nu dă eroare: e treaba ta să verifici (în lecțiile despre validare înveți cum).
- Cererea 3: câmpul culoare nu există în record, deci este ignorat.
- Cererea 4: JSON-ul este stricat (lipsește valoarea după cantitate), așa că Spring nu-l poate citi și răspunde cu 400, cu mesajul JSON parse error. Metoda nu rulează.
Datele în memorie și id-uri generate
Ca datele trimise să nu se piardă, le ții într-o listă, câmp al controller-ului. Spring creează un singur obiect din fiecare controller și îl folosește pentru toate cererile, deci lista rămâne între cereri. Id-ul îl dă serverul, cu un contor, nu clientul:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
record Nota(long id, String text) { }
@RestController
class NotaController {
private final List<Nota> note = new ArrayList<>();
private long ultimulId = 0;
@PostMapping("/note")
Nota adauga(@RequestBody Nota primita) {
ultimulId++;
Nota nota = new Nota(ultimulId, primita.text());
note.add(nota);
return nota;
}
@GetMapping("/note")
List<Nota> toate() {
return note;
}
}
// > GET /note
// > POST /note {"text": "Cumpără lapte"}
// > POST /note {"id": 99, "text": "Sună la bancă"}
// > GET /noteTomcat started on port 8080 (http)
Started Application
GET /note → 200
[]
POST /note → 200
{"id":1,"text":"Cumpără lapte"}
POST /note → 200
{"id":2,"text":"Sună la bancă"}
GET /note → 200
[{"id":1,"text":"Cumpără lapte"},{"id":2,"text":"Sună la bancă"}]Lista din controller dispare când oprești aplicația. Este suficient pentru a învăța; în modulul despre Spring Data JPA mute datele într-o bază de date, iar codul controller-ului rămâne aproape la fel.
Exemple reale
| Acțiunea utilizatorului | Cererea |
|---|---|
| își creează cont | POST /utilizatori cu {"email": ..., "parola": ...} |
| plasează o comandă | POST /comenzi cu produsele și adresa |
| lasă o recenzie | POST /produse/15/recenzii cu nota și textul |
| se autentifică | POST /login cu emailul și parola |
Parolele și alte date sensibile se trimit mereu în corp, niciodată în URL: adresele ajung în istoricul browserului și în jurnalele serverelor.
Greșeli frecvente
- **Uiți @RequestBody**: Spring nu citește corpul, iar obiectul primit are toate câmpurile goale (null, 0).
- Nume diferite în JSON și în record: {"Nume": ...} nu se potrivește cu componenta nume (contează literele mari).
- Lași clientul să aleagă id-ul: generează-l pe server.
- **Folosești List.of pentru date care se adaugă**: add aruncă excepție; folosește new ArrayList<>().
Pe scurt
- POST trimite date în corpul cererii, de obicei JSON (Content-Type: application/json).
- @PostMapping + @RequestBody Tip parametru transformă JSON-ul în obiect.
- Câmpurile lipsă primesc null/0, cele în plus sunt ignorate, JSON-ul stricat dă 400.
- Controller-ul este unul singur pentru toate cererile: o listă din el păstrează datele între cereri.
- Id-ul îl generează serverul, cu un contor.
Adaugă crearea de produse: POST /produse primește un produs în corp (nume și pret), îi dă id-ul următor (1, apoi 2...), îl adaugă în lista produse și îl întoarce. Ruta GET /produse există deja. Laboratorul trimite două POST-uri, un GET /produse și un POST cu JSON stricat (care trebuie să primească 400).
- Adaugă o metodă cu @PostMapping("/produse") și un parametru @RequestBody Produs primit.
- Crește ultimulId și construiește un Produs nou cu ultimulId, primit.nume() și primit.pret().
- Adaugă produsul nou în listă și întoarce-l.
Soluția exercițiului
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
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 = new ArrayList<>();
private long ultimulId = 0;
@PostMapping("/produse")
Produs adauga(@RequestBody Produs primit) {
ultimulId++;
Produs produs = new Produs(ultimulId, primit.nume(), primit.pret());
produse.add(produs);
return produs;
}
@GetMapping("/produse")
List<Produs> toate() {
return produse;
}
} 