Introducere în Inversiune de Control și de Injectare Dependență cu Primăvara

Prezentare

În acest articol, vom introduce conceptele de Cio (Inversiune de Control) și DI (Injectare Dependență), și apoi vom lua o privire la modul în care acestea sunt puse în aplicare în cadru de Primăvară.,

ce este inversarea controlului?,inversarea controlului este un principiu în ingineria software prin care controlul obiectelor sau porțiunilor unui program este transferat într-un container sau cadru. Este cel mai adesea folosit în contextul programării orientate pe obiecte.spre deosebire de programarea tradițională, în care codul nostru personalizat efectuează apeluri către o bibliotecă, IoC permite unui cadru să preia controlul fluxului unui program și să efectueze apeluri către codul nostru personalizat. Pentru a activa acest lucru, cadrele utilizează abstracții cu comportament suplimentar încorporat., Dacă dorim să adăugăm propriul nostru comportament, trebuie să extindem clasele cadrului sau să pluginăm propriile noastre clase.,

avantajele acestei arhitecturi sunt:

• decuplare executarea unei sarcini de aplicare a acestuia
• ceea ce face mai ușor pentru a comuta între diferite implementări
• o mai mare modularitate de un program
• o mai mare ușurință în testarea unui program prin izolarea unei componente sau batjocoritor dependențele sale și permițând componente pentru a comunica prin contracte

Inversiune de Control poate fi realizat prin diverse mecanisme cum ar fi: Strategia model de design, Servicii de Localizare model, Fabrica de model, și Dependența de Injecție (DI).,

ne vom uita la DI următoare.

ce este injecția de dependență?

injecția de dependență este un model prin care se implementează IoC, unde controlul inversat este setarea dependențelor obiectului.

actul de a conecta obiecte cu alte obiecte sau de a” injecta ” obiecte în alte obiecte, se face mai degrabă de un asamblor decât de obiectele în sine.,

Iată cum ați crea o dependență de obiect în programarea tradițională:

public class Store { private Item item; public Store() { item = new ItemImpl1(); }}

în exemplul de mai sus, trebuie să instanțiem o implementare a interfeței elementului în cadrul clasei Store în sine.folosind DI, putem rescrie exemplul fără a specifica implementarea elementului dorit:

public class Store { private Item item; public Store(Item item) { this.item = item; }}

în secțiunile următoare, vom vedea cum putem oferi implementarea elementului prin metadate.,atât CIO, cât și DI sunt concepte simple, dar au implicații profunde în modul în care ne structurăm sistemele, așa că merită bine înțelese.

containerul IOC cu arc

un container IoC este o caracteristică comună a cadrelor care implementează IoC.

în cadrul Spring, containerul IoC este reprezentat de aplicația de interfațăcontext. Containerul cu arc este responsabil pentru instanțierea, configurarea și asamblarea obiectelor cunoscute sub numele de fasole, precum și gestionarea ciclului lor de viață.,

cadru de Primăvară oferă mai multe implementări ale ApplicationContext interfață — ClassPathXmlApplicationContext și FileSystemXmlApplicationContext pentru aplicații de sine stătătoare, și WebApplicationContext pentru aplicații web.

pentru a asambla fasole, containerul utilizează metadate de configurare, care pot fi sub formă de configurație XML sau adnotări.

Iată o modalitate de a instantia manual un container:

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

pentru a seta atributul element în exemplul de mai sus, putem folosi metadate., Apoi, containerul va citi aceste metadate și îl va folosi pentru a asambla fasole în timpul rulării.

injecție dependență în primăvară se poate face prin Constructori, setteri sau câmpuri.

injecție de dependență bazată pe Constructor

în cazul injecției de dependență bazată pe constructor, containerul va invoca un constructor cu argumente reprezentând fiecare o dependență pe care dorim să o setăm.

Spring rezolvă fiecare argument în primul rând după tip, urmat de numele atributului și indexul pentru dezambiguizare., Să vedem configurația unei fasole și dependențele sale folosind adnotări:

adnotarea @Configuration indică faptul că clasa este o sursă de definiții de fasole. De asemenea, îl putem adăuga la mai multe clase de configurare.

@Bean adnotare este folosit pe o metodă pentru a defini o fasole. Dacă nu specificăm un nume personalizat, numele fasolei va fi implicit la numele metodei.

pentru o fasole cu domeniul de aplicare singleton implicit, Spring verifică mai întâi dacă o instanță cache a fasolei există deja și creează una nouă doar dacă nu., Dacă folosim scopul prototipului, containerul returnează o nouă instanță bean pentru fiecare apel de metodă.

un Alt mod de a crea configurația de fasole este prin configurare XML:

Setter pe bază de Injectare Dependență

Pentru setter pe bază de DI, containerul va apela metode setter de clasa noastră, după invocând un argument constructor sau nu-argument metodă statică fabrică pentru a instantia bean., Hai să creăm această configurație folosind adnotări:

@Beanpublic Store store() { Store store = new Store(); store.setItem(item1()); return store;}

putem folosi, de asemenea, XML pentru aceeași configurație de fasole:

<bean class="org.baeldung.store.Store"> <property name="item" ref="item1" /></bean>

Constructor pe baza și setter bazate pe tipuri de injecție pot fi combinate pentru același bean. Documentația Spring recomandă utilizarea injecției bazate pe constructor pentru dependențe obligatorii și injecției bazate pe setter pentru cele opționale.

7., Teren pe bază de Injectare Dependență

În caz de Teren pe bază de DI, putem injecta dependențele prin marcarea lor cu o @Autowired adnotare:

public class Store { @Autowired private Item item; }

în Timp ce construirea Magazin de obiect, dacă nu e constructor sau setter metoda de a injecta Element de fasole, recipientul se va folosi de reflecție pentru a injecta Element în Magazin.

de asemenea, putem realiza acest lucru folosind configurația XML.,

Această abordare ar putea arata simplu și curat, dar nu este recomandat să utilizați pentru că are câteva dezavantaje cum ar fi:

• Această metodă folosește reflecție pentru a injecta dependențe, care este mai costisitoare decât constructor sau pe baza de setter pe bază de injecție
• este foarte ușor de a păstra adăugarea de mai multe dependențe folosind acest abordare. Dacă utilizați injecție constructor având mai multe argumente ne-ar fi făcut să credem că clasa face mai mult de un lucru care poate încălca principiul responsabilității unice.,

Mai multe informații despre @Autowired adnotare pot fi găsite în cablare în articol de primăvară.

dependențe de Autowiring

cablarea permite containerului cu arc să rezolve automat dependențele dintre fasolea colaboratoare prin inspectarea boabelor care au fost definite.,

Există patru moduri de autowiring un bob de fasole, folosind o configurare XML:

• nu: valoarea implicită – acest lucru înseamnă că nu autowiring este folosit pentru fasole și trebuie să în mod explicit numele dependențele
• byName: autowiring se face pe baza numelui de proprietate, prin urmare Primăvară se va uita pentru o fasole cu același nume ca și proprietate, care trebuie să fie stabilite
• byType: similar cu byName autowiring, numai pe baza tipului de proprietate. Aceasta înseamnă că primăvara va căuta o fasole cu același tip de proprietate de setat., Dacă există mai mult de o fasole de acest tip, cadrul aruncă o excepție.,poate injecta, de asemenea, fasole folosind @Autowired adnotare pentru autowiring de tip:

  public class Store { @Autowired private Item item;}

  Dacă există mai mult de un bob de același tip, putem folosi @de Calificare adnotare pentru a face referință la o fasole cu numele:

  public class Store { @Autowired @Qualifier("item1") private Item item;}

  Acum, hai să autowire fasole de tip prin configurare XML:

  <bean class="org.baeldung.store.Store" autowire="byType"> </bean>

  apoi, să-i injecteze o fasole nume element în element proprietatea magazin de fasole de nume, prin XML:

  <bean class="org.baeldung.store.ItemImpl1" /><bean class="org.baeldung.store.Store" autowire="byName"></bean>

  de asemenea, putem trece peste autowiring prin definirea dependențelor în mod explicit prin constructor argumente sau setteri.,

  Lazy inițializate fasole

  în mod implicit, containerul creează și configurează toate fasole singleton în timpul inițializării. Pentru a evita acest lucru, puteți utiliza leneș-init atribut cu valoarea adevărat pe bean de configurare:

  <bean class="org.baeldung.store.ItemImpl1" lazy-init="true" />

  Ca o consecință, item1 bean va fi inițializate numai atunci când este solicitat, și nu la pornire., Avantajul acestui lucru este timpul de inițializare mai rapid, dar compromisul este că erorile de configurare pot fi descoperite numai după solicitarea fasolei, care ar putea fi câteva ore sau chiar zile după ce aplicația a rulat deja.

  concluzie

  în acest articol, am prezentat conceptele de inversare a controlului și injecției de dependență și le-am exemplificat în cadrul Spring.puteți citi mai multe despre aceste concepte în articolele lui Martin Fowler:

  • inversarea containerelor de Control și modelul de injecție a dependenței.,
  • inversarea controlului