In un mondo in cui lavoriamo quotidianamente con linguaggi di programmazione, tutti noi tendiamo a cercare metodi e trucchi per semplificarci la vita. Bene, Dependency Injection è una di queste tecniche che mira ad aiutare facilmente il codice dello sviluppatore fornendo le dipendenze di un altro oggetto. In questo articolo su What is Dependency Injection, ti aiuterò a comprendere questa tecnica in dettaglio.
I seguenti argomenti verranno trattati in questo articolo:
- Introduzione all'inserimento di dipendenze
- Inversione di controllo
- Tipi di inserimento delle dipendenze
- Vantaggi dell'inserimento delle dipendenze
- Implementa l'inserimento delle dipendenze utilizzando Spring Boot
Quindi, iniziamo con questo articolo.
Cos'è l'iniezione di dipendenza?
L'inserimento delle dipendenze è la capacità di un oggetto di fornire le dipendenze di un altro oggetto.
come chiudere un programma in java
Ora, sono abbastanza sicuro, potresti non aver capito nulla dalla definizione tecnica di cui sopra. Quindi, lascia che ti chiarisca la confusione.
Quando senti il termine dipendenza, cosa ti viene in mente?
Ovviamente, qualcosa che fa affidamento su qualcos'altro per il supporto, giusto?
Ebbene, è lo stesso, anche nel caso della programmazione.
La dipendenza nella programmazione è un approccio in cui una classe utilizza funzionalità specifiche di un'altra classe. Quindi, ad esempio, se consideri due classi A e B e dici che la classe A utilizza funzionalità della classe B, allora è implicito che la classe A ha una dipendenza della classe B. Ora, se stai codificando in Java, devi sapere quello, devicreare un'istanza della classe B prima che gli oggetti vengano utilizzati dalla classe A.
Quindi, se ora devo definire Dependency Injection per te, il processo di creazione di un oggetto per un'altra classe e lasciare che la classe che utilizzi direttamente la dipendenza sia chiamato Dependency Injection. Ha principalmente tre classi coinvolte:
Classe cliente: Questa è la classe dipendente e dipende dalla classe Service.
Classe di servizio: Questa classe fornisce un servizio alla classe client.
Classe iniettore: Questa classe è responsabile dell'iniezione dell'oggetto della classe di servizio nella classe client
Ora che hai capito cos'è la Dependency Injection, lascia che ti guidi ora attraverso il principio su cui si basa Dependency Injection.
Inversione di controllo
Come ho accennato in precedenza, l'inversione del controllo è un principio in base al quale viene effettuata l'iniezione di dipendenza. Inoltre, come suggerisce il nome, Inversion of Control è fondamentalmente utilizzato per invertire diversi tipi di responsabilità aggiuntive di una classe piuttosto che la responsabilità principale.
Se devo spiegarti in termini più semplici, prendi in considerazione un esempio, in cui hai la capacità di cucinare. Secondo il principio IoC, puoi invertire il controllo, quindi invece di cucinare il cibo, puoi semplicemente ordinare direttamente dall'esterno, dove ricevi il cibo a portata di mano. Così il processo del cibo consegnato a casa tua è chiamato inversione del controllo.
Non devi cucinare da solo, invece, puoi ordinare il cibo e lasciare che un addetto alle consegne ti consegni il cibo. In questo modo, non devi occuparti delle responsabilità aggiuntive e concentrarti solo sul lavoro principale.
Ora che conosci il principio alla base di Dependency Injection, lascia che ti guidi attraverso i tipi di Dependency Injection.
Tipi di inserimento delle dipendenze
Esistono principalmente tre tipi di Dependency Injection:
Iniezione del costruttore: In questo tipo di iniezione, l'iniettore fornisce la dipendenza tramite il costruttore della classe client.
Setter Injection / Property Injection: In questo tipo di iniezione, il metodo injector inietta la dipendenza dal metodo setter esposto dal client.
Iniezione dell'interfaccia: In questo tipo di iniezione, l'iniettore utilizza Interface per fornire dipendenza alla classe client. I client devono implementare un'interfaccia che esporrà un filemetodo setterqualeaccetta la dipendenza.
Fino ad ora, spero che abbiate capito il fatto che Dependency Injection è responsabile della creazione di oggetti, capire quali classi richiedono quegli oggetti e infine fornire a quelle classi gli oggetti. Quindi, in quella nota, esaminiamo ora i vantaggi di Dependency Injection.
Vantaggi dell'inserimento delle dipendenze
Prima di elencare i vantaggi di Dependency Injection, lascia che ti spieghi la necessità di questa iniezione a livello di settore, per aiutarti a comprendere meglio i vantaggi.
Considera uno scenario, in cui hai una classe di posta elettronica, la cui unica responsabilità è prendersi cura delle e-mail ricevute. Ora, questa classe avrà oggetti come 'All'indirizzo di posta elettronica', 'Dall'indirizzo di posta elettronica', 'Oggetto e corpo del messaggio di posta elettronica'.
Ora, se l'azienda vuole salvare messaggi di testo e audio, pensi che questa classe possa salvare il messaggio?
Bene, la risposta è no?
Questo perché la Classe Email non può gestire i parametri del testo e dei messaggi audio. In questi casi, dovrai ricreare la classe. Ora, ricreare la classe è un lavoro piuttosto macchinoso, soprattutto se devi farlo regolarmente. Invece, se usi Dependency Injection, puoi modificare gli oggetti in fase di esecuzione. Quindi, in questo modo, non devi ricreare la classe che ti aiuta ulteriormente in molti modi.
Quindi, se devo riassumere i vantaggi dell'inserimento delle dipendenze, i seguenti sono i vantaggi:
Va bene, quindi ora che conosci i vantaggi di Dependency Injection, andiamo avanti e vediamo come implementare Dependency Injection utilizzando Spring Boot.
Come implementare DI utilizzando Spring Boot?
Passo 1: Apri i tuoi Eclipse IDE e crea un file Applicazione Spring Boot facendo clic con il tasto destro e scegliendo Progetto Spring Starter . Quindi menziona il nome del progetto e fai clic su finire .
Per ottenere il progetto Spring Starter, è necessario installare Spring Tool Suite da Eclipse Marketplace. Nel caso in cui non hai installato Spring Too Suite, puoi fare riferimento al mio articolo su .
come usare l'ordinamento in c ++
Vedrai automaticamente che viene creato un file dell'applicazione come di seguito.
Passo 2: Successivamente, crea una classe nello stesso pacchetto. Per farlo, fai clic con il pulsante destro del mouse sul file -> scegli Classe e menziona il nome della classe. Quindi fare clic su finire . Questo creerà un file Classe file. Qui ho creato una classe Clienti. Fare riferimento di seguito.
Passaggio 3: Dopodiché, inseriamo alcune proprietà per la classe. Quindi, diciamo, includiamo ID cliente, nome del cliente e Nome del corso. Indica il codice di seguito.
pacchetto com.example.demo // nome pacchetto public class Customers {private int custid private String custname private String coursename}Passaggio 3.1: Una volta che hai finito, devi generare metodi Getter e Setter per queste proprietà. Per farlo, seleziona queste proprietà e fai clic con il tasto destro. Quindi scegli fonte -> Genera metodi Getter e Setter.
Il tuo codice fino ad ora dovrebbe essere il seguente:
pacchetto com.example.demo public class Clienti {private int custid private String custname private String coursename public int getCustid () {return custid} public void setCustid (int custid) {this.custid = custid} public String getCustname () {return custname } public void setCustname (String custname) {this.custname = custname} public String getCoursename () {return coursename} public void setCoursename (String coursename) {this.coursename = coursename}}Ora, considera uno scenario in cui devi creare un oggetto per i clienti e non vuoi farlo manualmente. In tale scenario, dovrai quindi utilizzare Dependency Injection, per ottenere gli oggetti ogni volta che ne hai bisogno.
Quindi, ora esaminiamo come possiamo ottenere lo stesso risultato.
Passaggio 4: Innanzitutto, modifica il file linea di corsa nel file di classe dell'applicazione a quanto segue:
Contesto ConfigurableApplicationContext = SpringApplication.run (DemoApplication.class, args)
Nota: se viene visualizzato un errore, importa quanto segue:
import org.springframework.boot.SpringApplication import org.springframework.boot.autoconfigure.SpringBootApplication import org.springframework.context.ConfigurableApplicationContext
Questa riga di codice sopra restituirà un oggetto al momento dell'esecuzione. Ora aggiungi il seguente codice nel file dell'applicazione.
clienti c = context.getBean (customers.class)
La riga sopra, dirà al compilatore di restituire un oggetto della classe cliente. Fare riferimento di seguito.
Passaggio 4.1: Ora, per verificare se funziona o meno, tu può tornare alla classe Cliente e aggiungi un metodo come segue:
public void display () {System.out.println ('Object Returned Successfully')}Questo metodo visualizzerà un output 'Oggetto restituito con successo' in caso di esecuzione riuscita.
Passaggio 4.2: Successivamente, devi tornare al file dell'applicazione e menzionare quanto segue:
c.display ()
In questo modo si chiama l'oggetto della classe Customers con un riferimento al metodo di visualizzazione. Fare riferimento all'immagine sottostante per il codice della classe Application fino ad ora:
Ora, se esegui il progetto, vedrai un file eccezione di Nessun bean di qualificazione di tipo . Questo perché la classe cliente che hai definito non è uno Spring Bean, ovvero non è un oggetto Spring. Fare riferimento di seguito.
Passaggio 4.3: Quindi, per dirlo allo Spring Container, abbiamo bisogno di un oggetto della classe del cliente. Per farlo, devi menzionare il file @ Annotazione componente , nella classe Customer. Il codice nella classe Customers dovrebbe essere il seguente:
pacchetto com.example.demo import org.springframework.stereotype.Component @Component public class Clienti {private int custid private String custname private String coursename public int getCustid () {return custid} public void setCustid (int custid) {this.custid = custid} public String getCustname () {return custname} public void setCustname (String custname) {this.custname = custname} public String getCoursename () {return coursename} public void setCoursename (String coursename) {this.coursename = coursename} public void display () {System.out.println ('Object Returned Successfully')}}Poi, quando parli dei clienti c = context.getBean (customers.class) il compilatore verificherà se nel contenitore è disponibile o meno un bean cliente.
Se Bean è disponibile, il framework Spring sta inserendo l'oggetto cliente nella tua applicazione. Quindi, fondamentalmente, questo oggetto viene creato dal framework Spring, che può essere ulteriormente utilizzato nell'applicazione.
Quindi, se eseguo questo progetto ora, vedrai un output che Object Returned Successfully. Fare riferimento di seguito.
Questo è fondamentalmente il modo in cui puoi implementare Dependency Injection.
Esempio: inserimento di dipendenze mediante annotazione cablata automaticamente
Spero che tu abbia capito come funziona Dependency Injection in Spring Boot. Ora, estendiamo questo esempio e vediamo ulteriormente come una classe dipendente dall'altra classe ha utilizzato le funzionalità di quella classe in Spring Boot.
Passo 1: Creane uno nuovo file di classe , di nuovo facendo clic con il pulsante destro del mouse sul pacchetto e scegliendo Nuovo -> Classe. Ora, menziona il nome della classe come sotto e fai clic su Finire.
Passo 2: Successivamente, inseriamo alcune proprietà per la classe. Quindi, diciamo, includiamo TechID, Techname. Indica il codice di seguito.
pacchetto com.example.demo public class Technologies {private int techid private String techname}Passaggio 2.1: Una volta che hai finito, genera Metodi Getter e Setter per queste proprietà facendo clic con il pulsante destro del mouse sul file e quindi scegliendo Sorgente -> Genera metodi Getter e Setter.
puoi lanciare un double a un int
Passaggio 3: Ora, diciamo, dobbiamo creare un metodo che stampi ' Riuscito “. Per farlo menziona il codice:
public void tech () {System.out.println ('Successful')}Il tuo codice fino ad ora dovrebbe apparire come di seguito:
pacchetto com.example.demo public class Technologies {private int techid private String techname public int getTechid () {return techid} public void setTechid (int techid) {this.techid = techid} public String getTechname () {return techname} public void setTechname (String techname) {this.techname = techname} public void tech () {System.out.println ('Successful')}}Passaggio 4: Ora, per chiamare il metodo tech () nel classe clienti , devi creare un oggetto della classe di tecnologie. Quindi menziona la seguente riga di codice nella classe dei clienti:
private Technologies techdetail
Passaggio 4.1: Una volta che hai finito, genera Metodi Getter e Setter per queste proprietà da facendo clic con il pulsante destro del mouse sul file e poi scegli Sorgente -> Genera metodi Getter e Setter.
Passaggio 5: Successivamente, per utilizzare il file metodo tech () , devi menzionare techdetail.tech () sotto il metodo di visualizzazione della classe dei clienti . Inoltre, per assicurarti che l'oggetto techdetail sia istanziato, menziona @ Annotazione componente è il Classe di tecnologie. Fare riferimento di seguito.
Ora, quando esegui questo progetto, vedrai un file Eccezione puntatore nullo . Questo perché ora il file La classe del cliente dipende dalla classe delle tecnologie e tuttavia non conosce l'esistenza della classe delle tecnologie .
Quindi, per consentire al Cliente di riconoscere la classe Technologies, è necessario inserire il file @ Annotazione cablata nella classe Clienti. Il codice finale della classe clienti dovrebbe essere il seguente:
pacchetto com.example.demo import org.springframework.beans.factory.annotation.Autowired import org.springframework.stereotype.Component @Component public class Customers {private int custid private String custname private String coursename @Autowired private Technologies techdetail public Technologies getTechdetail ( ) {return techdetail} public void setTechdetail (Technologies techdetail) {this.techdetail = techdetail} public int getCustid () {return custid} public void setCustid (int custid) {this.custid = custid} public String getCustname () {return custname } public void setCustname (String custname) {this.custname = custname} public String getCoursename () {return coursename} public void setCoursename (String coursename) {this.coursename = coursename} public void display () {System.out.println ( 'Oggetto restituito con successo') techdetail.tech ()}}Una volta eseguiti questi file, vedrai gli output come Oggetto restituito correttamente e con successo, il che implica che la nostra dipendenza dalle classi è stata soddisfatta. Fare riferimento di seguito.
Ora che hai finito con l'articolo, controlla il file da Edureka, una società di formazione online affidabile con una rete di oltre 250.000 studenti soddisfatti sparsi in tutto il mondo.
Hai domande per noi? Si prega di menzionarlo nella sezione commenti di questo 'Che cos'è l'iniezione di dipendenza? 'Articolo e ti risponderemo il prima possibile.