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

Structura unei aplicații Spring Boot

Ai scris deja două servere mici. Acum te uiți „sub capotă”: ce face de fapt @SpringBootApplication, ce se întâmplă când apelezi SpringApplication.run și cum arată un proiect Spring Boot adevărat, cu fișierele și pachetele lui.

Clasa principală, încă o dată

Orice aplicație Spring Boot are o clasă principală: o clasă obișnuită Java, cu metoda main, adnotată cu @SpringBootApplication. De aici pornește totul.

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

main este aceeași metodă main din cursul de Java: punctul de intrare al programului. Diferența este că, în loc să scrii tu logica aici, îi dai controlul lui Spring prin SpringApplication.run(...). Primul argument (Application.class) îi spune lui Spring care este clasa principală, iar args sunt argumentele din linia de comandă.

Ce ascunde @SpringBootApplication

@SpringBootApplication este o scurtătură: o singură adnotare care le pune pe trei, fiecare cu rolul ei.

AdnotareaCe facePe înțeles
@Configurationclasa poate declara configurări„aici pot fi setări ale aplicației”
@EnableAutoConfigurationSpring configurează singur ce găsește în proiect„ai Spring Web? pornesc un server Tomcat”
@ComponentScancaută clasele adnotate (@RestController și altele)„găsesc controllerele tale fără să le enumeri”

Nu trebuie să scrii cele trei adnotări separat; e suficient să știi ideea. Auto-configurarea este „magia” lui Spring Boot: pentru că proiectul are dependența web, pornește un server; dacă ar avea o bază de date, ar configura conexiunea.

De ce contează scanarea

@ComponentScan caută clase în pachetul clasei principale și în subpachetele lui. De aceea, într-un proiect real, clasa principală stă în pachetul de sus (ro.magazin), iar controllerele în subpachete (ro.magazin.produs). O clasă pusă în afara acestui pachet nu este găsită.

Ce face SpringApplication.run

1
Creează contextul aplicației: un „container” în care Spring ține toate obiectele pe care le administrează (le vei numi bean-uri mai târziu în curs).
2
Caută clasele adnotate (@RestController și altele) și creează câte un obiect din fiecare. Tu nu scrii niciodată new SalutController().
3
Leagă fiecare @GetMapping de calea lui, ca să știe ce metodă apelează pentru fiecare cerere.
4
Pornește serverul web Tomcat pe portul 8080 și afișează Started Application.
5
Lasă aplicația să aștepte cereri. Programul nu se oprește la sfârșitul lui main: serverul rulează până când îl oprești (Ctrl+C).

Codul scris în main înainte de run se execută înainte ca Spring să pornească, iar cel de după run se execută când serverul este deja gata:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        System.out.println("Pregătesc aplicația...");
        SpringApplication.run(Application.class, args);
        System.out.println("Aplicația a pornit, aștept cereri.");
    }
}

@RestController
class OrarController {
    @GetMapping("/orar")
    String orar() {
        return "Luni-Vineri 9-18";
    }
}

// > GET /orar
Pregătesc aplicația...
Tomcat started on port 8080 (http)
Started Application
Aplicația a pornit, aștept cereri.
GET /orar → 200
Luni-Vineri 9-18

Ordinea liniilor arată exact pașii: mai întâi textul de dinainte, apoi pornirea serverului, apoi textul de după run, iar abia apoi cererea. În proiectele reale, main rămâne de obicei doar cu linia run; pentru mesaje la pornire se folosesc jurnalele (log-uri), pe care le înveți mai târziu.

Cum arată un proiect real

Când generezi un proiect pe start.spring.io, primești o structură de directoare standard (Maven):

magazin/
├── pom.xml                         dependențele și versiunea Java
├── mvnw, mvnw.cmd                  Maven inclus în proiect
└── src/
    ├── main/
    │   ├── java/ro/magazin/
    │   │   ├── MagazinApplication.java     clasa principală
    │   │   └── produs/
    │   │       └── ProdusController.java
    │   └── resources/
    │       └── application.properties  configurarea
    └── test/
        └── java/ro/magazin/
            └── MagazinApplicationTests.java
  • pom.xml descrie proiectul: numele, versiunea Java și dependențele (de exemplu spring-boot-starter-web, care aduce serverul web și JSON-ul).
  • src/main/java conține codul, împărțit în pachete (ro.magazin.produs); fiecare clasă are fișierul ei, iar primul rând al fișierului este package ro.magazin.produs;.
  • src/main/resources/application.properties conține configurarea (portul, numele aplicației, setări proprii); îl folosești în lecția 15.
  • src/test/java conține testele automate.
În laborator

Totul stă într-un singur fișier, Application.java, fără linia package și fără pom.xml. Laboratorul are deja „dependențele” incluse. Spring găsește clasele la fel, iar ce înveți se aplică identic într-un proiect real.

Greșeli frecvente

  • **Uiți SpringApplication.run**: programul rulează main și se oprește imediat; nu pornește niciun server.
  • **Dai altă clasă lui run**: primul argument trebuie să fie clasa adnotată cu @SpringBootApplication.
  • Pui controllerul în alt pachet decât cel al aplicației (în proiect real): @ComponentScan nu-l găsește, iar adresele dau 404.
  • **Scrii logică importantă în main**: acolo nu ai încă acces la serverul pornit; logica stă în controllere (și, mai târziu, în servicii).

Pe scurt

  • @SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan.
  • SpringApplication.run creează contextul, găsește clasele tale, pornește Tomcat și așteaptă cereri.
  • Codul din main dinaintea lui run apare înaintea liniilor de pornire.
  • Un proiect real are pom.xml, src/main/java (pachete), src/main/resources și src/test/java; laboratorul pune totul într-un fișier.
Exercițiul tău

Magazinul Ana vrea un mesaj în consolă la pornire și o pagină „despre”. În main, afișează Pornesc magazinul... înainte de SpringApplication.run. Apoi adaugă endpoint-ul GET /despre, care întoarce Magazinul Ana, din 2020.

  • În main, înainte de linia SpringApplication.run(...), adaugă System.out.println("Pornesc magazinul...");.
  • Păstrează apelul SpringApplication.run(Application.class, args).
  • În DespreController adaugă o metodă cu @GetMapping("/despre") care întoarce Magazinul Ana, din 2020.
Ordinea liniilor din rezultat contează: mesajul trebuie să apară înaintea liniei Tomcat started....

Soluția exercițiului

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        System.out.println("Pornesc magazinul...");
        SpringApplication.run(Application.class, args);
    }
}

@RestController
class DespreController {
    @GetMapping("/despre")
    String despre() {
        return "Magazinul Ana, din 2020";
    }
}
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 3 · Structura unei aplicații Spring Boot
Progres 0% 0 din 20
Lecția curentă 3 / 18 Introducere