...
← Curs Spring Boot și REST API: toate lecțiile
Lecția 10 · Metode HTTP

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 /note
Tomcat 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ă"}]
1
Prima cerere GET întoarce []: lista e goală.
2
Fiecare POST crește contorul ultimulId și construiește o notă nouă cu acel id și textul primit.
3
În a doua cerere clientul trimite "id": 99, dar serverul îl ignoră și îi dă id-ul 2. Clientul nu are voie să-și aleagă id-ul.
4
Ultimul GET arată ambele note.
Memorie, nu bază de date

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 utilizatoruluiCererea
își creează contPOST /utilizatori cu {"email": ..., "parola": ...}
plasează o comandăPOST /comenzi cu produsele și adresa
lasă o recenziePOST /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.
Exercițiul tău

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.
Urmează modelul cu notele din lecție: ultimulId++; Produs produs = new Produs(ultimulId, ...); produse.add(produs); return produs;

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;
    }
}
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 10 · Date trimise de client: POST și @RequestBody
Progres 0% 0 din 20
Lecția curentă 10 / 18 Metode http