Recapitulare: primul tău API cu Spring Boot
Ai terminat primul modul. Ai pornit de la un server care răspundea cu un text și ai ajuns la un API REST complet, cu JSON, coduri de status corecte, antete și configurare. În lecția aceasta pui totul într-un singur loc: ce ai învățat, ce folosești pentru fiecare nevoie, greșelile de evitat și ce urmează.
Drumul de până acum
| Lecțiile | Ce ai învățat |
|---|---|
| 1–3 | ce este un API și Spring Boot, HTTP (cereri, răspunsuri, coduri), cum pornește aplicația |
| 4–5 | rute multiple, mai multe controllere, prefixul comun cu @RequestMapping |
| 6–7 | date din adresă: @PathVariable (identifică) și @RequestParam (filtrează) |
| 8–9 | răspunsuri JSON cu record-uri, liste și Map-uri |
| 10–11 | date de la client: POST, PUT, PATCH, DELETE cu @RequestBody |
| 12–14 | ResponseEntity, codurile 201/204/404, antete în cerere și în răspuns |
| 15 | configurare cu application.properties și @Value |
| 16–17 | un API CRUD complet și un mini-proiect pornit de la un tichet |
Vreau să... folosesc...
| Vreau să... | Folosesc |
|---|---|
| fac o clasă să răspundă la cereri | @RestController |
| pun un prefix comun rutelor | @RequestMapping("/api/x") pe clasă |
| răspund la o cerere GET / POST / PUT / PATCH / DELETE | @GetMapping, @PostMapping, @PutMapping, @PatchMapping, @DeleteMapping |
| citesc id-ul din /produse/7 | @PathVariable long id |
| citesc ?q=java&pagina=2 | @RequestParam (cu defaultValue sau required = false) |
| citesc JSON-ul din corp | @RequestBody Tip obiect |
| citesc un antet | @RequestHeader("Nume") |
| întorc JSON | un record, o listă sau un Map (Jackson face restul) |
| întorc 404 | ResponseEntity.notFound().build() |
| întorc 201 cu adresa resursei | ResponseEntity.created(URI.create(...)).body(...) |
| întorc 204 | ResponseEntity.noContent().build() |
| adaug un antet în răspuns | ResponseEntity.ok().header("Nume", "valoare").body(...) |
| citesc o setare din fișier | @Value("${cheie:implicit}") |
Totul într-un exemplu
Un singur controller care folosește aproape tot ce ai învățat: prefix, filtru cu valoare implicită, Optional pentru 404, antet în răspuns și o proprietate din fișier (antetul X-Cafenea nu apare în laborator, pentru că exercițiul cere alte antete).
/* application.properties
app.cafenea.nume=Cafeneaua Ana
*/
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Value;
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 Bautura(long id, String nume, double pret) { }
@RestController
@RequestMapping("/api/bauturi")
class BauturaController {
@Value("${app.cafenea.nume}")
private String cafenea;
private final List<Bautura> bauturi = new ArrayList<>(List.of(
new Bautura(1, "Espresso", 9.0),
new Bautura(2, "Latte", 14.5)
));
@GetMapping
ResponseEntity<List<Bautura>> toate(@RequestParam(defaultValue = "1000") double pretMaxim) {
List<Bautura> rezultat = bauturi.stream().filter(b -> b.pret() <= pretMaxim).toList();
return ResponseEntity.ok().header("X-Cafenea", cafenea).body(rezultat);
}
@GetMapping("/{id}")
ResponseEntity<Bautura> una(@PathVariable long id) {
return bauturi.stream().filter(b -> b.id() == id).findFirst()
.map(b -> ResponseEntity.ok(b))
.orElse(ResponseEntity.notFound().build());
}
}
// > GET /api/bauturi?pretMaxim=10
// > GET /api/bauturi/2
// > GET /api/bauturi/8Tomcat started on port 8080 (http)
Started Application
GET /api/bauturi?pretMaxim=10 → 200
[{"id":1,"nume":"Espresso","pret":9.0}]
GET /api/bauturi/2 → 200
{"id":2,"nume":"Latte","pret":14.5}
GET /api/bauturi/8 → 404Citește codul de sus în jos și numește fiecare adnotare fără să te uiți la tabel. Dacă reușești, ești gata pentru modulul următor.
Greșelile cele mai frecvente
| Simptom | Cauza probabilă |
|---|---|
| toate rutele dau 404 | lipsește @RestController sau calea are o greșeală (slash, literă mare) |
| 405 Method Not Allowed | ai folosit altă metodă HTTP decât cea din adnotare |
| obiectul primit are câmpuri null/0 | ai uitat @RequestBody sau cheile JSON nu se potrivesc cu record-ul |
| 400 Bad Request | lipsește un @RequestParam/@RequestHeader obligatoriu, tipul nu se poate converti sau JSON-ul este stricat |
| aplicația nu pornește: Ambiguous mapping | două metode pe aceeași rută |
| aplicația nu pornește: Could not resolve placeholder | proprietatea din @Value lipsește din fișier și nu are valoare implicită |
| UnsupportedOperationException la add/remove | lista a fost creată cu List.of; folosește ArrayList |
Ce urmează în cursul complet
- Controllere, DTO-uri, validare și erori: cum transformă Jackson clasele în JSON, DTO-uri, @Valid și mesaje de eroare clare cu ProblemDetail.
- Servicii și dependency injection: muți logica din controller în servicii, configurare avansată, profiluri.
- Spring Data JPA: datele trec din listă într-o bază de date, cu entități, repository-uri și interogări.
- Securitate și teste: protejezi rutele și scrii teste automate cu JUnit și MockMvc.
- Microservicii cu Spring Cloud: mai multe servicii care vorbesc între ele, gateway, retry, circuit breaker și mesaje.
După acest modul poți explica ce este un API REST, ce face fiecare metodă HTTP, ce înseamnă codurile 200, 201, 204, 400, 404, 405 și 500 și cum construiești un controller CRUD în Spring Boot. Sunt întrebări care apar aproape la orice interviu pentru Java Junior.
Pe scurt
- Un API REST are resurse (substantive la plural) și operații (metode HTTP), cu coduri de status corecte.
- Spring Boot leagă cererile de metode prin adnotări și transformă singur obiectele în JSON și invers.
- ResponseEntity îți dă control complet asupra codului, antetelor și corpului.
- Configurarea stă în application.properties, citită cu @Value.
- Exercițiul final folosește toate aceste piese împreună.
Proiectul final al modulului: un API pentru agenda de contacte. Fișierul application.properties conține app.agenda.nume=Agenda Anei. Implementează: GET /agenda (Agenda Anei: N contacte, cu numele citit cu @Value), GET /contacte cu filtrul opțional oras, GET /contacte/{id} (200 sau 404), POST /contacte (201 cu Location) și DELETE /contacte/{id} (204 sau 404). Laboratorul rulează 7 cereri și afișează antetul Location.
- Citește numele agendei cu @Value("${app.agenda.nume}") și folosește-l în GET /agenda, împreună cu numărul de contacte.
- GET /contacte: @RequestParam(required = false) String oras; fără el, toată lista, altfel doar contactele din acel oraș (compară cu equals).
- GET /contacte/{id}: ResponseEntity cu 200 sau 404.
- POST /contacte: id-ul următor (de la 4), 201 cu Location: /contacte/{id} și contactul în corp.
- DELETE /contacte/{id}: 204 dacă a fost ș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.beans.factory.annotation.Value;
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 Contact(long id, String nume, String telefon, String oras) { }
@RestController
class AgendaController {
@Value("${app.agenda.nume}")
private String numeAgenda;
private final List<Contact> contacte = new ArrayList<>(List.of(
new Contact(1, "Ana Pop", "0722000111", "Cluj-Napoca"),
new Contact(2, "Mihai Ionescu", "0733000222", "Iași"),
new Contact(3, "Ioana Dinu", "0744000333", "Cluj-Napoca")
));
private long ultimulId = 3;
@GetMapping("/agenda")
String agenda() {
return numeAgenda + ": " + contacte.size() + " contacte";
}
@GetMapping("/contacte")
List<Contact> lista(@RequestParam(required = false) String oras) {
if (oras == null) {
return contacte;
}
return contacte.stream().filter(c -> c.oras().equals(oras)).toList();
}
@GetMapping("/contacte/{id}")
ResponseEntity<Contact> unul(@PathVariable long id) {
return contacte.stream().filter(c -> c.id() == id).findFirst()
.map(c -> ResponseEntity.ok(c))
.orElse(ResponseEntity.notFound().build());
}
@PostMapping("/contacte")
ResponseEntity<Contact> adauga(@RequestBody Contact primit) {
ultimulId++;
Contact contact = new Contact(ultimulId, primit.nume(), primit.telefon(), primit.oras());
contacte.add(contact);
return ResponseEntity.created(URI.create("/contacte/" + contact.id())).body(contact);
}
@DeleteMapping("/contacte/{id}")
ResponseEntity<Void> sterge(@PathVariable long id) {
if (contacte.removeIf(c -> c.id() == id)) {
return ResponseEntity.noContent().build();
}
return ResponseEntity.notFound().build();
}
} 