HTTP pe înțeles: cereri și răspunsuri
Clientul și serverul vorbesc într-o limbă comună: HTTP. În lecția aceasta afli ce conține o cerere, ce conține un răspuns, ce înseamnă metodele GET, POST, PUT, DELETE și cum citești codurile de status precum 200, 404 și 405.
Ce conține o cerere HTTP
De fiecare dată când aplicația de pe telefon vrea ceva de la server, trimite o cerere HTTP. Cererea este un mesaj text cu patru părți:
| Parte | Ce este | Exemplu |
|---|---|---|
| metoda | ce vrei să faci | GET, POST, PUT, DELETE |
| calea | la ce resursă te referi | /produse/15 |
| antetele | informații în plus despre cerere | Accept-Language: ro, Authorization: Bearer ... |
| corpul | datele trimise (opțional) | {"nume": "Mouse", "pret": 99} |
Cum arată o cerere „pe fir”, exact cum o primește serverul:
GET /produse/15 HTTP/1.1 Host: magazin.ro Accept: application/json Accept-Language: ro
Prima linie conține metoda și calea. Urmează antetele, câte unul pe linie, sub forma Nume: valoare. O cerere GET nu are de obicei corp: doar cere ceva.
Browserul, aplicația mobilă sau Postman construiesc cererea. Spring Boot o citește și o transformă în apeluri ale metodelor tale. Tu decizi doar ce răspunde serverul.
Ce conține un răspuns HTTP
Serverul răspunde tot cu un mesaj text, în trei părți: codul de status (un număr care spune cum a mers), antetele și corpul (datele, de obicei JSON sau text).
HTTP/1.1 200 OK Content-Type: text/plain;charset=UTF-8 Laptop Nova 14, 3499 lei
În laborator vezi forma scurtă a răspunsului: o linie METODĂ cale → cod, apoi corpul. Antetele nu se afișează decât atunci când exercițiul le cere (vei vedea asta în lecțiile despre coduri de status și antete).
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@RestController
class ProdusController {
@GetMapping("/produs")
String produs() {
return "Laptop Nova 14, 3499 lei";
}
}
// > GET /produs
// > POST /produs
// > GET /produseTomcat started on port 8080 (http)
Started Application
GET /produs → 200
Laptop Nova 14, 3499 lei
POST /produs → 405
{"status":405,"error":"Method Not Allowed","path":"/produs"}
GET /produse → 404
{"status":404,"error":"Not Found","path":"/produse"}Metodele HTTP: ce vrei să faci
Metoda spune serverului intenția cererii. Aceeași cale poate face lucruri diferite în funcție de metodă: GET /cos arată coșul, POST /cos adaugă ceva în el.
| Metoda | Intenția | Exemplu real |
|---|---|---|
| GET | citește date, nu schimbă nimic | pagina unui produs, lista de comenzi |
| POST | creează ceva nou | adaugi un produs în coș, plasezi o comandă, te autentifici |
| PUT | înlocuiește o resursă existentă | îți modifici adresa de livrare |
| DELETE | șterge o resursă | scoți un produs din coș |
În Spring fiecare metodă HTTP are adnotarea ei: @GetMapping, @PostMapping, @PutMapping, @DeleteMapping. Pe POST, PUT și DELETE le folosești cu adevărat în lecțiile 10 și 11; aici vezi doar că aceeași cale poate avea două metode diferite:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@RestController
class CosController {
@GetMapping("/cos")
String vezi() {
return "Coșul are 2 produse";
}
@PostMapping("/cos")
String adauga() {
return "Produs adăugat în coș";
}
}
// > GET /cos
// > POST /cos
// > PUT /cosTomcat started on port 8080 (http)
Started Application
GET /cos → 200
Coșul are 2 produse
POST /cos → 200
Produs adăugat în coș
PUT /cos → 405
{"status":405,"error":"Method Not Allowed","path":"/cos"}GET /cos și POST /cos ajung la metode Java diferite. Pentru PUT /cos n-ai scris nimic, deci Spring răspunde cu 405: calea există, metoda nu.
Codurile de status: cum a mers
Codul de status este primul lucru pe care îl verifică un client. Prima cifră spune familia:
| Familia | Înseamnă | Coduri des întâlnite |
|---|---|---|
| 2xx | succes | 200 OK, 201 Created, 204 No Content |
| 3xx | redirecționare (mergi altundeva) | 301 Moved Permanently, 302 Found |
| 4xx | clientul a greșit ceva | 400 Bad Request, 401 Unauthorized, 404 Not Found, 405 Method Not Allowed |
| 5xx | serverul a avut o problemă | 500 Internal Server Error, 503 Service Unavailable |
- 200 OK: cererea a reușit, iar corpul conține răspunsul.
- 404 Not Found: calea cerută nu există pe server (sau resursa cu acel id nu există).
- 405 Method Not Allowed: calea există, dar nu pentru metoda folosită (ai trimis POST unde serverul acceptă doar GET).
Regula simplă: 4xx = problema e la client (adresă greșită, date lipsă), 5xx = problema e la server (un bug în codul tău). Un API bun nu răspunde niciodată cu 500 pentru o greșeală a clientului.
JSON-ul de eroare al Spring Boot
Când Spring Boot răspunde singur cu o eroare, corpul este un mic JSON cu trei câmpuri:
{"status":405,"error":"Method Not Allowed","path":"/produs"}- status: codul de status, ca număr;
- error: numele standard al codului, în engleză;
- path: calea cerută, ca să știi la ce cerere se referă.
Aplicația mobilă sau site-ul poate citi acest JSON și poate afișa un mesaj prietenos („Pagina nu există”). Mai târziu în curs înveți să-ți scrii propriile răspunsuri de eroare, cu mesaje în română.
Exemple reale
| Situația | Cererea | Răspunsul |
|---|---|---|
| deschizi pagina unui produs | GET /produse/15 | 200 cu datele produsului |
| produsul a fost șters între timp | GET /produse/15 | 404 |
| adaugi produsul în coș | POST /cos | 201 sau 200 |
| te autentifici cu parola greșită | POST /login | 401 |
| o aplicație veche trimite DELETE pe o rută care nu-l acceptă | DELETE /produse | 405 |
| serverul are un bug | orice cerere | 500 |
În realitate poți vedea toate cererile unui site în browser: apasă F12, deschide tab-ul Network și reîncarcă pagina. Vei vedea metoda, calea și codul de status pentru fiecare cerere.
Pe scurt
- O cerere HTTP are metodă, cale, antete și (opțional) corp; un răspuns are cod de status, antete și corp.
- GET citește, POST creează, PUT înlocuiește, DELETE șterge.
- 2xx = succes, 4xx = greșeala clientului, 5xx = problema serverului.
- 404 = calea nu există; 405 = calea există, dar nu pentru metoda trimisă.
- Erorile implicite ale Spring Boot au corpul {"status", "error", "path"}.
Orice server are nevoie de câteva adrese simple prin care echipa verifică dacă funcționează. Adaugă în StareController două endpoint-uri: GET /ping răspunde cu pong, iar GET /versiune răspunde cu 1.0. Laboratorul trimite GET /ping, GET /versiune și POST /ping (care trebuie să primească 405, pentru că /ping acceptă doar GET).
- Adaugă o metodă cu @GetMapping("/ping") care întoarce pong.
- Adaugă o metodă cu @GetMapping("/versiune") care întoarce 1.0.
- Nu adăuga @PostMapping: cererea POST /ping trebuie să primească 405.
Soluția exercițiului
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@RestController
class StareController {
@GetMapping("/ping")
String ping() {
return "pong";
}
@GetMapping("/versiune")
String versiune() {
return "1.0";
}
} 