Modificare și ștergere: PUT și DELETE
Ai citit date (GET) și ai creat date (POST). Acum le modifici și le ștergi. PUT înlocuiește o resursă existentă, DELETE o șterge, iar PATCH modifică doar o parte din ea. Afli și ce înseamnă că o operație este idempotentă.
PUT: înlocuiește resursa
PUT /contacte/2 înseamnă: „resursa cu id-ul 2 să arate de acum exact așa”. Cererea are două surse de date: id-ul din cale (@PathVariable) și datele noi din corp (@RequestBody). DELETE /contacte/1 înseamnă „șterge resursa 1” și nu are corp.
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 Contact(long id, String nume, String telefon) { }
@RestController
@RequestMapping("/contacte")
class ContactController {
private final List<Contact> contacte = new ArrayList<>(List.of(
new Contact(1, "Ana", "0722000111"),
new Contact(2, "Mihai", "0733000222")
));
@GetMapping
List<Contact> toate() {
return contacte;
}
@PutMapping("/{id}")
Contact inlocuieste(@PathVariable long id, @RequestBody Contact primit) {
Contact nou = new Contact(id, primit.nume(), primit.telefon());
for (int i = 0; i < contacte.size(); i++) {
if (contacte.get(i).id() == id) {
contacte.set(i, nou);
}
}
return nou;
}
@DeleteMapping("/{id}")
void sterge(@PathVariable long id) {
contacte.removeIf(c -> c.id() == id);
}
}
// > PUT /contacte/2 {"nume": "Mihai Ionescu", "telefon": "0744000333"}
// > DELETE /contacte/1
// > GET /contacteTomcat started on port 8080 (http)
Started Application
PUT /contacte/2 → 200
{"id":2,"nume":"Mihai Ionescu","telefon":"0744000333"}
DELETE /contacte/1 → 200
GET /contacte → 200
[{"id":2,"nume":"Mihai Ionescu","telefon":"0744000333"}]new ArrayList<>(List.of(...)) face o copie modificabilă a unei liste fixe: pornești cu câteva elemente și poți apoi folosi set, add și removeIf.
Ce întorc PUT și DELETE
| Metoda | Ce întoarce de obicei | În Spring |
|---|---|---|
| PUT | resursa după modificare | metoda întoarce obiectul nou |
| DELETE | nimic | metoda void (200 gol) sau, mai corect, 204 No Content (lecția 13) |
| PATCH | resursa după modificare | metoda întoarce obiectul nou |
Ce se întâmplă dacă id-ul nu există? În codul de mai sus, PUT pe un id inexistent nu schimbă nimic, dar răspunde tot cu 200, iar DELETE la fel. Un API bun ar răspunde cu 404: înveți cum în lecția următoare, cu ResponseEntity.
PATCH: modificare parțială
La PUT trimiți resursa întreagă: un câmp lipsă devine null. PATCH trimite doar ce se schimbă, iar restul rămâne cum era. O variantă simplă este să primești corpul ca Map și să iei din el doar cheile trimise:
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 Setari(String tema, String limba) { }
@RestController
class SetariController {
private Setari setari = new Setari("luminoasă", "ro");
@GetMapping("/setari")
Setari vezi() {
return setari;
}
@PatchMapping("/setari")
Setari modifica(@RequestBody Map<String, String> schimbari) {
String tema = schimbari.getOrDefault("tema", setari.tema());
String limba = schimbari.getOrDefault("limba", setari.limba());
setari = new Setari(tema, limba);
return setari;
}
}
// > PATCH /setari {"tema": "întunecată"}
// > PATCH /setari {"tema": "întunecată"}
// > GET /setariTomcat started on port 8080 (http)
Started Application
PATCH /setari → 200
{"tema":"întunecată","limba":"ro"}
PATCH /setari → 200
{"tema":"întunecată","limba":"ro"}
GET /setari → 200
{"tema":"întunecată","limba":"ro"}Limba a rămas ro, pentru că cererea nu a trimis-o. getOrDefault ia valoarea nouă dacă cheia există, altfel o păstrează pe cea veche.
Idempotența, pe înțeles
O operație este idempotentă dacă, executată de mai multe ori, lasă serverul în aceeași stare ca executată o dată. Contează pentru că rețelele pică: dacă aplicația nu primește răspunsul, poate retrimite cererea fără grijă doar dacă e idempotentă.
| Metoda | Idempotentă? | De ce |
|---|---|---|
| GET | da | doar citește |
| PUT | da | „resursa 2 să fie X” de două ori = tot X |
| DELETE | da | după prima ștergere, resursa nu mai există; a doua nu schimbă nimic |
| POST | nu | două POST /comenzi = două comenzi (și două plăți!) |
În exemplul cu setări, al doilea PATCH identic nu a schimbat nimic. De aceea magazinele online dezactivează butonul „Plătește” după primul click: POST repetat ar crea o comandă în plus.
Greșeli frecvente
- Iei id-ul din corp în loc de cale: la PUT /sarcini/2 resursa modificată este 2, oricare ar fi id-ul trimis în JSON.
- **Ștergi dintr-o listă List.of**: removeIf aruncă excepție; folosește ArrayList.
- **Folosești PUT pentru modificări parțiale**: câmpurile netrimise devin null; pentru asta există PATCH.
- **Pui date în corpul unui DELETE**: multe servere și clienți îl ignoră; id-ul stă în cale.
Pe scurt
- @PutMapping("/{id}") cu @PathVariable + @RequestBody: înlocuiește resursa întreagă.
- @DeleteMapping("/{id}"): șterge; o metodă void răspunde 200 fără corp.
- @PatchMapping: modifică doar câmpurile trimise.
- GET, PUT, DELETE sunt idempotente; POST nu.
Lista de sarcini are trei elemente. Adaugă PUT /sarcini/{id}, care înlocuiește titlul sarcinii cu id-ul dat (din corp vine {"titlu": "..."}) și întoarce sarcina nouă, și DELETE /sarcini/{id}, care șterge sarcina. Laboratorul trimite GET /sarcini, PUT /sarcini/2, DELETE /sarcini/1 și din nou GET /sarcini.
- Adaugă @PutMapping("/{id}") cu @PathVariable long id și @RequestBody Sarcina primita.
- Construiește new Sarcina(id, primita.titlu()) și pune-o în listă în locul celei cu același id (set).
- Adaugă @DeleteMapping("/{id}") care șterge sarcina cu removeIf.
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 Sarcina(long id, String titlu) { }
@RestController
@RequestMapping("/sarcini")
class SarcinaController {
private final List<Sarcina> sarcini = new ArrayList<>(List.of(
new Sarcina(1, "Citește lecția"),
new Sarcina(2, "Rezolvă exercițiul"),
new Sarcina(3, "Fă o pauză")
));
@GetMapping
List<Sarcina> toate() {
return sarcini;
}
@PutMapping("/{id}")
Sarcina inlocuieste(@PathVariable long id, @RequestBody Sarcina primita) {
Sarcina noua = new Sarcina(id, primita.titlu());
for (int i = 0; i < sarcini.size(); i++) {
if (sarcini.get(i).id() == id) {
sarcini.set(i, noua);
}
}
return noua;
}
@DeleteMapping("/{id}")
void sterge(@PathVariable long id) {
sarcini.removeIf(s -> s.id() == id);
}
} 