Un API CRUD complet în memorie
Ai învățat pe rând fiecare metodă HTTP și fiecare cod de status. Acum le pui împreună într-un API CRUD complet: creare, citire, modificare și ștergere pe aceeași resursă, cu răspunsurile corecte pentru fiecare situație, inclusiv când resursa nu există.
CRUD: patru operații, o resursă
CRUD vine de la Create, Read, Update, Delete: cele patru lucruri pe care le faci cu aproape orice date. În REST, fiecare operație are o metodă HTTP și o adresă după o convenție pe care o recunoaște orice programator:
| Operația | Ruta | Succes | Resursa lipsește |
|---|---|---|---|
| Read (toate) | GET /carti | 200 + listă | nu se aplică (listă goală) |
| Read (una) | GET /carti/{id} | 200 + carte | 404 |
| Create | POST /carti | 201 + Location + carte | nu se aplică |
| Update | PUT /carti/{id} | 200 + carte | 404 |
| Delete | DELETE /carti/{id} | 204 | 404 |
Observă convenția: colecția are un nume la plural (/carti), iar o resursă anume este colecția urmată de id (/carti/3). Metoda HTTP spune ce faci, adresa spune cu ce.
Bucățile, puse împreună
Nu există nimic nou de învățat, doar de combinat. Fiecare bucată vine dintr-o lecție anterioară:
- prefixul comun pe clasă: @RequestMapping("/carti") (lecția 5);
- id-ul din cale: @PathVariable (lecția 6); datele din corp: @RequestBody (lecția 10);
- lista modificabilă și contorul de id-uri: ArrayList și ultimulId (lecțiile 10 și 11);
- codurile: ok, notFound, created, noContent (lecțiile 12 și 13);
- căutarea cu Optional, într-o metodă ajutătoare cauta(id) folosită de mai multe rute.
cauta(id) nu are adnotare, deci nu este o rută: este o metodă Java obișnuită a controller-ului. Metodele ajutătoare elimină codul repetat; în modulul următor le vei muta într-un serviciu, separat de controller.
Cazurile „nu există”
Diferența dintre un API de jucărie și unul serios este felul în care tratează cererile pentru resurse inexistente. PUT și DELETE trebuie să răspundă cu 404 când id-ul lipsește, nu să pretindă că au reușit:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import java.net.URI;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
record Film(long id, String titlu, int an) { }
@RestController
@RequestMapping("/filme")
class FilmController {
private final List<Film> filme = new ArrayList<>(List.of(new Film(1, "Moromeții", 1987)));
Optional<Film> cauta(long id) {
return filme.stream().filter(f -> f.id() == id).findFirst();
}
@GetMapping("/{id}")
ResponseEntity<Film> unul(@PathVariable long id) {
return cauta(id).map(f -> ResponseEntity.ok(f)).orElse(ResponseEntity.notFound().build());
}
@PutMapping("/{id}")
ResponseEntity<Film> inlocuieste(@PathVariable long id, @RequestBody Film primit) {
for (int i = 0; i < filme.size(); i++) {
if (filme.get(i).id() == id) {
Film nou = new Film(id, primit.titlu(), primit.an());
filme.set(i, nou);
return ResponseEntity.ok(nou);
}
}
return ResponseEntity.notFound().build();
}
@DeleteMapping("/{id}")
ResponseEntity<Void> sterge(@PathVariable long id) {
boolean sters = filme.removeIf(f -> f.id() == id);
return sters ? ResponseEntity.noContent().build() : ResponseEntity.notFound().build();
}
}
// > PUT /filme/1 {"titlu": "Moromeții", "an": 1988}
// > PUT /filme/5 {"titlu": "Filantropica", "an": 2002}
// > DELETE /filme/1
// > DELETE /filme/1
// > GET /filme/1Tomcat started on port 8080 (http)
Started Application
PUT /filme/1 → 200
{"id":1,"titlu":"Moromeții","an":1988}
PUT /filme/5 → 404
DELETE /filme/1 → 204
DELETE /filme/1 → 404
GET /filme/1 → 404Al doilea DELETE răspunde cu 404, dar starea serverului este aceeași ca după primul: filmul lipsește. Operația rămâne idempotentă (lecția 11); codul diferă doar ca să spună clientului ce s-a întâmplat.
Cum testezi un API CRUD
Un API CRUD se verifică printr-un scenariu: o succesiune de cereri care trece prin toate operațiile, fiecare bazându-se pe cele dinainte. Așa lucrează și testerii, în Postman sau cu teste automate:
Scenariul exercițiului face exact pașii aceștia. Când primești un tichet „API pentru X” la serviciu, scrie-ți întâi scenariul: îți arată ce rute și ce coduri trebuie să implementezi.
Greșeli frecvente
- **PUT pe un id inexistent creează resursa** sau răspunde 200: clientul crede că a modificat ceva ce nu există. Răspunde cu 404.
- **Id-ul generat din lista.size() + 1**: după o ștergere, două resurse pot primi același id. Folosește un contor care doar crește.
- Verbe în adrese (/carti/sterge/3, /adaugaCarte): metoda HTTP spune deja ce faci.
- **Location cu adresa colecției** (/carti) în loc de adresa resursei noi (/carti/3).
Pe scurt
- CRUD = Create (POST, 201), Read (GET, 200), Update (PUT, 200), Delete (DELETE, 204).
- Colecția la plural (/carti), resursa cu id (/carti/{id}).
- GET, PUT și DELETE pe un id inexistent răspund cu 404.
- O metodă ajutătoare cauta(id) cu Optional evită codul repetat.
- Testezi API-ul printr-un scenariu care trece prin toate operațiile.
Construiește API-ul CRUD complet pentru cărți. GET /carti există deja. Adaugă: GET /carti/{id} (200 sau 404), POST /carti (201, Location: /carti/{id}, id-ul următor după 2), PUT /carti/{id} (200 cu cartea înlocuită sau 404) și DELETE /carti/{id} (204 sau 404). Laboratorul rulează un scenariu de 8 cereri și afișează antetul Location.
- Scrie o metodă ajutătoare cauta(long id) care întoarce Optional<Carte> și folosește-o la GET /carti/{id}.
- La POST, crește ultimulId, construiește cartea nouă și întoarce ResponseEntity.created(URI.create("/carti/" + id)).body(carte).
- La PUT, înlocuiește cartea cu set(i, ...) dacă o găsești, altfel 404.
- La DELETE, folosește rezultatul lui removeIf: 204 dacă a șters, altfel 404.
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.net.URI;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
record Carte(long id, String titlu, String autor) { }
@RestController
@RequestMapping("/carti")
class CarteController {
private final List<Carte> carti = new ArrayList<>(List.of(
new Carte(1, "Enigma Otiliei", "George Călinescu"),
new Carte(2, "Ion", "Liviu Rebreanu")
));
private long ultimulId = 2;
Optional<Carte> cauta(long id) {
return carti.stream().filter(c -> c.id() == id).findFirst();
}
@GetMapping
List<Carte> toate() {
return carti;
}
@GetMapping("/{id}")
ResponseEntity<Carte> una(@PathVariable long id) {
return cauta(id).map(c -> ResponseEntity.ok(c)).orElse(ResponseEntity.notFound().build());
}
@PostMapping
ResponseEntity<Carte> adauga(@RequestBody Carte primita) {
ultimulId++;
Carte carte = new Carte(ultimulId, primita.titlu(), primita.autor());
carti.add(carte);
return ResponseEntity.created(URI.create("/carti/" + carte.id())).body(carte);
}
@PutMapping("/{id}")
ResponseEntity<Carte> inlocuieste(@PathVariable long id, @RequestBody Carte primita) {
for (int i = 0; i < carti.size(); i++) {
if (carti.get(i).id() == id) {
Carte noua = new Carte(id, primita.titlu(), primita.autor());
carti.set(i, noua);
return ResponseEntity.ok(noua);
}
}
return ResponseEntity.notFound().build();
}
@DeleteMapping("/{id}")
ResponseEntity<Void> sterge(@PathVariable long id) {
boolean stearsa = carti.removeIf(c -> c.id() == id);
if (stearsa) {
return ResponseEntity.noContent().build();
}
return ResponseEntity.notFound().build();
}
} 