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

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 /contacte
Tomcat 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"}]
1
@PutMapping("/{id}") (cu prefixul clasei: /contacte/{id}) primește id-ul și contactul nou.
2
Metoda construiește un contact cu id-ul din cale (nu din corp) și îl pune în listă în locul celui vechi, cu set(i, ...).
3
@DeleteMapping("/{id}") șterge din listă contactul cu acel id, cu removeIf.
4
Metoda sterge întoarce void: răspunsul are codul 200 și corpul gol, de aceea după DELETE /contacte/1 → 200 nu apare nimic.
Listă modificabilă

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

MetodaCe întoarce de obiceiÎn Spring
PUTresursa după modificaremetoda întoarce obiectul nou
DELETEnimicmetoda void (200 gol) sau, mai corect, 204 No Content (lecția 13)
PATCHresursa după modificaremetoda î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 /setari
Tomcat 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ă.

MetodaIdempotentă?De ce
GETdadoar citește
PUTda„resursa 2 să fie X” de două ori = tot X
DELETEdadupă prima ștergere, resursa nu mai există; a doua nu schimbă nimic
POSTnudouă 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.
Exercițiul tău

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.
Parcurge lista cu for (int i = 0; i < sarcini.size(); i++) și, când sarcini.get(i).id() == id, apelează sarcini.set(i, noua).

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);
    }
}
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 11 · Modificare și ștergere: PUT și DELETE
Progres 0% 0 din 20
Lecția curentă 11 / 18 Metode http