MyCodeSchool

Pasul 1 din 5

Spring Boot

Pasul 1 din 5 · Ce construiești

  • Spring Boot
  • Mediu
  • 14 minute

Primii pași cu Spring: containerul și injecția de dependențe

Construiești o stație meteo de buzunar: un senzor, un raport și un afișaj. Nu scrii niciun new pentru ele. Spring creează obiectele și le leagă între ele. Așa arată când pornește:

MeteoApp, în terminal
Afară: 21.5 °C

Pare puțin pentru o aplicație Spring Boot, și exact asta e ideea: toată munca e în felul în care se leagă clasele. Ca să vezi doar ieșirea programului, logurile Spring sunt reduse la avertismente, din application.properties:

application.properties
spring.main.banner-mode=offlogging.level.root=warn

Pasul 2 din 5

Urmărește pornirea, pas cu pas

Tot programul încape într-un fișier. Apasă pe „Linia următoare” și urmărește ce bean-uri apar în container și în ce ordine.

MeteoApp.java
package ro.exemplu.meteo;import org.springframework.boot.*;import org.springframework.boot.autoconfigure.*;import org.springframework.stereotype.*;@SpringBootApplicationpublic class MeteoApp {    public static void main(String[] args) {        SpringApplication.run(MeteoApp.class, args);    }}interface Senzor {    double grade();}@Componentclass SenzorBalcon implements Senzor {    public double grade() {        return 21.5;    }}@Serviceclass Raport {    private final Senzor senzor;    Raport(Senzor senzor) {        this.senzor = senzor;    }    String text() {        return "Afară: " + senzor.grade() + " °C";    }}@Componentclass Afisaj implements CommandLineRunner {    private final Raport raport;    Afisaj(Raport raport) {        this.raport = raport;    }    public void run(String... args) {        System.out.println(raport.text());    }}

Bean-uri în container

Ce apare pe ecran


      

  1. Linia 10. SpringApplication.run pornește containerul, obiectul care va crea și va ține minte toate bean-urile. Primul bean e chiar clasa MeteoApp.
  2. Linia 7. @SpringBootApplication cere scanarea pachetului ro.exemplu.meteo. Spring găsește trei clase marcate: SenzorBalcon, Raport și Afisaj. Deocamdată are doar lista, niciun obiect.
  3. Linia 18. SenzorBalcon nu cere nimic în constructor, deci poate fi creat imediat. Numele bean-ului e numele clasei cu literă mică: senzorBalcon.
  4. Linia 28. Constructorul lui Raport cere un Senzor. Spring caută în container un bean de acest tip, găsește exact unul, senzorBalcon, și îl trimite ca argument. Asta e injecția de dependențe.
  5. Linia 39. Afisaj cere un Raport, care există deja. Toate bean-urile sunt gata.
  6. Linia 42. După pornire, Spring Boot apelează run pentru fiecare bean de tip CommandLineRunner. Aici e locul unde aplicația începe treaba.
  7. Linia 32. raport.text() întreabă senzorul. Raport nu știe ce senzor a primit: știe doar că are metoda grade(), care dă 21.5.
  8. Linia 43. Textul ajunge pe ecran.
  9. Gata. Nu există server web și nici alt runner, așa că Spring închide containerul și programul se oprește.

Întrebare rapidă

De ce e creat senzorBalcon înaintea lui raport?

Răspuns: pentru că raport are nevoie de el.

Un obiect nu poate fi construit fără argumentele constructorului. Spring urmează dependențele: ca să facă raport, face întâi ce-i trebuie. Ordinea din fișier și tipul adnotării nu contează aici.

Pasul 3 din 5

Containerul, pe înțeles

Patru idei, apoi trei greșeli care opresc aplicația, cu mesajele reale din Spring Boot.

Fără Spring, legi tu obiectele

FaraSpring.java
interface Senzor {    double grade();}class SenzorBalcon implements Senzor {    public double grade() {        return 21.5;    }}class Raport {    private final Senzor senzor;    Raport(Senzor senzor) {        this.senzor = senzor;    }    String text() {        return "Afară: " + senzor.grade();    }}void main() {    Senzor s = new SenzorBalcon();    Raport r = new Raport(s);    IO.println(r.text());}

Ce apare pe ecran

Afară: 21.5

În Java simplu, cineva trebuie să scrie new SenzorBalcon() și să-l dea raportului. La trei clase merge. La cincizeci, codul care leagă obiectele devine el însuși o problemă.

Cu Spring, controlul se inversează: clasele doar declară ce le trebuie, iar containerul decide ce creează și cui dă. De aici vine numele, IoC, de la inversion of control.

Adnotările care fac dintr-o clasă un bean

Adnotări care înregistrează bean-uri
AdnotareCând o pui
@Componentorice clasă pe care s-o creeze Spring
@Servicelogica aplicației
@Repositoryaccesul la date
@RestControllerendpoint-uri HTTP
@Configurationo clasă cu metode @Bean

Pentru container, toate sunt @Component; numele diferite îi spun cititorului rolul clasei. Scanarea pornește din pachetul clasei cu @SpringBootApplication și coboară în subpachete. O clasă din alt pachet nu e găsită, chiar dacă are adnotarea.

Injecția prin constructor

Uită-te din nou la Raport: câmpul e private final, iar valoarea vine din constructor. Când o clasă are un singur constructor, Spring îl folosește automat; nu e nevoie de @Autowired.

Avantajele sunt practice. Obiectul nu poate exista fără senzor, deci nu ai null-uri ascunse. Într-un test, scrii new Raport(senzorFals) și verifici raportul fără să pornești Spring. Și, pentru că Raport depinde de interfața Senzor, poți schimba senzorul fără să atingi raportul.

@Bean, pentru clasele care nu sunt ale tale

Setari.java
@Configurationclass Setari {    @Bean    NumberFormat format() {        return NumberFormat.getInstance(                Locale.of("ro"));    }}

Pe NumberFormat din Java nu poți pune @Component. Scrii în schimb o metodă cu @Bean într-o clasă @Configuration: Spring o apelează o dată, la pornire, și păstrează rezultatul ca bean, cu numele metodei, format.

Implicit, fiecare bean există într-un singur exemplar (scope singleton). Toți cei care cer un NumberFormat primesc același obiect.

Capcană: ai uitat adnotarea

Fără @Component, clasa e cod Java obișnuit: Spring n-o creează, iar raportul rămâne fără senzor. Aplicația nici nu pornește:

MeteoApp.java, fără @Component
class SenzorBalcon implements Senzor {    public double grade() {        return 21.5;    }}
***************************
APPLICATION FAILED TO START
***************************

Description:

Parameter 0 of constructor in ro.exemplu.meteo.Raport required a bean of type 'ro.exemplu.meteo.Senzor' that could not be found.

Action:

Consider defining a bean of type 'ro.exemplu.meteo.Senzor' in your configuration.

Repară punând @Component deasupra clasei și verifică dacă e în pachetul aplicației sau într-un subpachet.

Capcană: doi candidați pentru același loc

Adaugi un al doilea senzor. Constructorul lui Raport cere „un Senzor”, iar acum sunt doi:

MeteoApp.java, clasa nouă
@Componentclass SenzorPivnita implements Senzor {    public double grade() {        return 12.0;    }}
Description:

Parameter 0 of constructor in ro.exemplu.meteo.Raport required a single bean, but 2 were found:
	- senzorBalcon: defined in file […/SenzorBalcon.class]
	- senzorPivnita: defined in file […/SenzorPivnita.class]
…
Action:

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

Repară cum spune chiar mesajul: @Primary pe senzorul folosit implicit sau @Qualifier("senzorPivnita") pe parametrul care îl vrea pe celălalt. Programul complet de la final le folosește pe amândouă.

Capcană: un bean creat cu new

Ecran e un bean, dar obiectul de mai jos e făcut cu new. Spring nu știe de el, deci nu-i completează câmpul @Autowired:

MeteoApp.java, varianta greșită
@Componentclass Ecran {    @Autowired    Raport raport;    void arata() {        System.out.println(raport.text());    }}@Componentclass Afisaj implements CommandLineRunner {    public void run(String... args) {        Ecran ecran = new Ecran();        ecran.arata();    }}
java.lang.NullPointerException: Cannot invoke "ro.exemplu.meteo.Raport.text()" because "this.raport" is null
	at ro.exemplu.meteo.Ecran.arata(MeteoApp.java:42) ~[classes/:na]
	at ro.exemplu.meteo.Afisaj.run(MeteoApp.java:50) ~[classes/:na]

Repară cerând bean-ul în constructor, Afisaj(Ecran ecran), în loc de new Ecran(). Injecția prin constructor ar fi semnalat problema încă de la pornire.

Pasul 4 din 5

Verifică-te

Cinci întrebări noi. După fiecare răspuns vezi imediat de ce e așa.

1 din 5 · Prezice ieșirea

Aplicația are aceste trei bean-uri. Ce afișează?

Q1App.java
@Componentclass SenzorBalcon implements Senzor {    public double grade() {        return 21.5;    }}@Component@Primaryclass SenzorPivnita implements Senzor {    public double grade() {        return 12.0;    }}@Componentclass Afisaj implements CommandLineRunner {    private final Senzor senzor;    Afisaj(Senzor senzor) {        this.senzor = senzor;    }    public void run(String... args) {        System.out.println(senzor.grade());    }}

Răspuns: 12.0.

Sunt doi candidați, dar @Primary îl alege pe SenzorPivnita ori de câte ori se cere un Senzor fără alte precizări.

2 din 5 · Alege varianta

Vrei ca un java.time.Clock să fie bean. Cum faci?

Răspuns: o metodă @Bean într-o clasă @Configuration.

Codul lui Clock e în JDK, nu-l poți adnota. Metoda @Bean îi spune lui Spring cum să-l obțină; de exemplu return Clock.systemDefaultZone();.

3 din 5 · Prezice ieșirea

Ce afișează?

Q3App.java
@Componentclass Contor {    int n;}@Componentclass Afisaj implements CommandLineRunner {    private final Contor a;    private final Contor b;    Afisaj(Contor a, Contor b) {        this.a = a;        this.b = b;    }    public void run(String... args) {        a.n++;        b.n++;        System.out.println(a.n + " " + (a == b));    }}

Răspuns: 2 true.

Bean-urile sunt implicit singleton: a și b sunt același obiect. Două incrementări pe același contor dau 2, iar a == b e true.

4 din 5 · Alege varianta

Clasa cu @SpringBootApplication e în pachetul ro.exemplu.meteo. Unde poate sta un @Component ca să fie găsit?

Răspuns: în ro.exemplu.meteo.senzori.

Scanarea coboară din pachetul aplicației în subpachete, nu urcă. Un pachet părinte sau unul vecin rămâne nescanat, iar la pornire primești eroarea cu „could not be found”.

5 din 5 · Alege varianta

De ce e preferată injecția prin constructor față de un câmp cu @Autowired?

Răspuns: obiectul e complet de la creare și ușor de testat.

Cu un câmp @Autowired, un obiect făcut cu new rămâne cu null, ca în a treia capcană. Viteza și scope-ul nu depind de felul injecției.

Pasul 5 din 5

Ce ai învățat

Programul complet

Stația are acum doi senzori. Cel de pe balcon e @Primary, cel din pivniță e cerut explicit cu @Qualifier, iar formatarea în stil românesc vine dintr-un bean @Bean.

MeteoApp.java
package ro.exemplu.complet;import java.text.NumberFormat;import java.util.Locale;import org.springframework.beans.factory.annotation.*;import org.springframework.boot.*;import org.springframework.boot.autoconfigure.*;import org.springframework.context.annotation.*;import org.springframework.stereotype.*;@SpringBootApplicationpublic class MeteoApp {    public static void main(String[] args) {        SpringApplication.run(MeteoApp.class, args);    }}interface Senzor {    double grade();}@Component@Primaryclass SenzorBalcon implements Senzor {    public double grade() {        return 21.5;    }}@Componentclass SenzorPivnita implements Senzor {    public double grade() {        return 12.0;    }}@Configurationclass Setari {    @Bean    NumberFormat format() {        return NumberFormat.getInstance(                Locale.of("ro"));    }}@Serviceclass Raport {    private final Senzor afara;    private final Senzor pivnita;    private final NumberFormat format;    Raport(Senzor afara,           @Qualifier("senzorPivnita")           Senzor pivnita,           NumberFormat format) {        this.afara = afara;        this.pivnita = pivnita;        this.format = format;    }    String text() {        return "Afară: "                + format.format(afara.grade())                + " °C\nPivniță: "                + format.format(pivnita.grade())                + " °C";    }}@Componentclass Afisaj implements CommandLineRunner {    private final Raport raport;    Afisaj(Raport raport) {        this.raport = raport;    }    public void run(String... args) {        System.out.println(raport.text());    }}

Ce apare pe ecran

Afară: 21,5 °C
Pivniță: 12 °C

Continuă cu