...
← Curs Spring Boot și REST API: toate lecțiile
Lecția 16 · CRUD

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țiaRutaSuccesResursa lipsește
Read (toate)GET /carti200 + listănu se aplică (listă goală)
Read (una)GET /carti/{id}200 + carte404
CreatePOST /carti201 + Location + cartenu se aplică
UpdatePUT /carti/{id}200 + carte404
DeleteDELETE /carti/{id}204404

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.
Metode ajutătoare

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/1
Tomcat 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 → 404
1
PUT /filme/1 găsește filmul, îl înlocuiește și întoarce 200.
2
PUT /filme/5: bucla nu găsește id-ul, deci metoda ajunge la notFound(). Nu se creează nimic nou.
3
removeIf întoarce true dacă a șters ceva. Primul DELETE dă 204, al doilea 404: filmul nu mai există.
4
GET /filme/1 după ștergere: 404.
DELETE de două ori

Al 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:

1
citești lista inițială (GET /carti);
2
creezi o resursă (POST) și notezi id-ul primit;
3
o citești după id (GET /carti/3) ca să confirmi că a fost salvată;
4
o modifici (PUT) și încerci și un id inexistent (404);
5
ștergi o resursă (DELETE, 204) și verifici că nu mai există (GET, 404).

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

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.
Exemplul cu filmele din lecție are deja PUT și DELETE cu 404; POST cu 201 este cel din lecția 13.

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();
    }
}
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 16 · Un API CRUD complet în memorie
Progres 0% 0 din 20
Lecția curentă 16 / 18 Crud