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:
Linia 10.SpringApplication.run pornește containerul, obiectul care va crea și va ține minte toate bean-urile. Primul bean e chiar clasa MeteoApp.
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.
Linia 18.SenzorBalcon nu cere nimic în constructor, deci poate fi creat imediat. Numele bean-ului e numele clasei cu literă mică: senzorBalcon.
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.
Linia 39.Afisaj cere un Raport, care există deja. Toate bean-urile sunt gata.
Linia 42. După pornire, Spring Boot apelează run pentru fiecare bean de tip CommandLineRunner. Aici e locul unde aplicația începe treaba.
Linia 32.raport.text() întreabă senzorul. Raport nu știe ce senzor a primit: știe doar că are metoda grade(), care dă 21.5.
Linia 43. Textul ajunge pe ecran.
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.
1
Fără Spring, legi tu obiectele
FaraSpring.java
interface Senzor {doublegrade();}class SenzorBalcon implements Senzor {publicdoublegrade() {return21.5; }}class Raport {privatefinal Senzor senzor; Raport(Senzor senzor) {this.senzor = senzor; } String text() {return"Afară: " + senzor.grade(); }}voidmain() { 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.
2
Adnotările care fac dintr-o clasă un bean
Adnotări care înregistrează bean-uri
Adnotare
Când o pui
@Component
orice clasă pe care s-o creeze Spring
@Service
logica aplicației
@Repository
accesul la date
@RestController
endpoint-uri HTTP
@Configuration
o 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.
3
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.
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 {publicdoublegrade() {return21.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:
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:
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.
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
Un bean e un obiect creat și ținut de containerul Spring; tu nu scrii new pentru el.
@Component, @Service și celelalte marchează clasele din pachetul aplicației și din subpachete.
Dependențele vin prin constructor, în câmpuri final; Spring le creează primele.
Două implementări pentru același tip se lămuresc cu @Primary sau @Qualifier; clasele străine devin bean-uri cu @Bean.
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.