Iniezione di dipendenza primaverile

Iniezione di dipendenza o IOC è un concetto fondamentale del framework Spring che aiuta a gestire gli oggetti di fagioli nell'applicazione. L'iniezione di dipendenza, o DI come suggerisce il nome, gestisce gli oggetti dipendenti e rende il nostro codice vagamente accoppiato.

Ad esempio, un'applicazione a molla può creare diversi moduli dipendenti l'uno dall'altro per formare un'applicazione completamente funzionante. Gli oggetti dipendenti devono fornire la propria istanza durante il runtime altrimenti l'applicazione può rompersi. Quindi, come framework, Spring ha gestito questa situazione e fornisce oggetti di fagioli in fase di esecuzione.

Il IOC (inversione del controllo) fa questo compito, io.e., inietta dipendenze durante la creazione di fagioli. È un contenitore di base che crea, configura, gestisce oggetti e gestisce persino l'intero ciclo di vita di un oggetto.

La primavera DI è classificata principalmente come a Basato su costruttori Iniezione di dipendenza e a Basato su setter iniezione di dipendenza.

In questo articolo, lo faremo Per prima cosa impara a basato su costruttori Iniezione di dipendenza e spostamento a base di setter nell'argomento successivo.

Cominciamo con un'applicazione Spring basata su Maven che contiene i seguenti file Java e configurazione.

// Dipendente.Giava

È una semplice classe di fagioli che contiene due proprietà e metodi di cotter setter.

Pacchetto com.Linuxhint.fagioli;
Org di importazione.Springframework.stereotipo.Componente;
@Componente
dipendente della classe pubblica
ID privato int;
Nome stringa privato;
public String getName ()
Nome di ritorno;

public void setName (nome stringa)
Questo.nome = nome;

public int getId ()
restituzione ID;

public void setID (int id)
Questo.id = id;

// Responsabile del progetto.Giava

Qui, abbiamo creato un altro fagiolo che contiene alcuni metodi getter-setter e il punto importante è osservare il costruttore ProjectManager () che funge da DI basato su costruttore. Crea un oggetto bean della classe dei dipendenti durante il caricamento nel contesto dell'applicazione.

Pacchetto com.Linuxhint.fagioli;
Org di importazione.Springframework.stereotipo.Componente;
@Componente
Classe pubblica ProjectManager
impiegato dei dipendenti privati;
Public ProjectManager (dipendente dipendente)
Questo.dipendente = dipendente;

public void setInfo (int id, nome stringa)
dipendente.setid (id);
dipendente.setname (nome);

public String getInfo ()
restituire “id =“+dipendente.getid ()+"\ nname ="+dipendente.getName ();

// Springapp.Giava

Questa è la classe principale che carica SpringConfig. Qui, abbiamo usato il metodo getBean () per ottenere un oggetto della classe ProjectManager. Dopodiché, impostiamo e otteniamo valori per questo oggetto.

Pacchetto com.Linuxhint;
Org di importazione.Springframework.contesto.annotazione.AnnotationConfigApplicationContext;
Importa com.Linuxhint.fagioli.Responsabile del progetto;
Classe pubblica Springapp
public static void main (string [] args)
AnnotationConfigApplicationContext AC = new AnnotationConfigApplicationContext (SpringConfig.classe);
ProjectManager PM = AC.GetBean (ProjectManager.classe);
PM.setinfo (102, "romano");
String Result = PM.ottenere informazioni();
Sistema.fuori.println (risultato);
AC.vicino();

// SpringConfing.Giava

Questa è la classe di configurazione che aiuta a configurare l'applicazione. È importante durante la configurazione di applicazioni utilizzando annotazioni.

Pacchetto com.Linuxhint;
Org di importazione.Springframework.contesto.annotazione.Componentscan;
Org di importazione.Springframework.contesto.annotazione.Configurazione;
@Configurazione
@Componentscan ("com.Linuxhint.*")
Classe pubblica SpringConfig

// pom.XML

Questo file contiene dipendenze Maven per il progetto Spring.

4.0.0
com.Linuxhint
Springapp
0.0.1-snapshot
Springapp
Una semplice app di primavera


org.Springframework
primavera
$ primavera.versione


org.Springframework
a primavera
$ primavera.versione


Javax.annotazione
Javax.Annotazione-API
1.3.2



5.2.8.PUBBLICAZIONE

Struttura del progetto

Dopo aver creato tutti i file e il codice, la nostra struttura del progetto è mostrata di seguito:

Esegui l'applicazione

Ora esegui l'applicazione e deve mostrare il seguente output nella finestra della console:

id = 102
Nome = romano

Configurazione utilizzando il codice XML

Puoi farlo se si desidera configurare l'applicazione utilizzando il codice XML. Tuttavia, la configurazione XML è vecchia moda per farlo, ma è ancora supportata dalla Framework Spring. Hai una scelta per configurare l'applicazione utilizzando le annotazioni XML o Java.

Nel caso XML, dobbiamo solo creare un file ApplicationContext.XML e leggilo nel Springapp File di classe. Tuo ApplicationContext.XML Il file deve contenere il seguente codice XML:

// ApplicationContext.XML

xmlns: xsi = "http: // www.W3.org/2001/xmlschema-istance "
xmlns: p = "http: // www.Springframework.org/schema/p "
XSI: schemalocation = "http: // www.Springframework.org/schema/fagioli
http: // www.Springframework.Org/Schema/Beans/Spring-Beans-3.0.XSD ">
class = "com.Linuxhint.fagioli.ProjectManager " />

Qui, il tag viene utilizzato per specificare la classe di fagioli e l'ID specifica l'istanza del fagiolo. Il tag specifica la dipendenza dal costruttore e il tag per l'iniezione dell'oggetto nel costruttore.

Conclusione

In questo articolo, abbiamo appreso l'iniezione di dipendenza primaverile basata sul costruttore. Abbiamo imparato la sua configurazione usando annotazioni Java e XML. Dal momento che è un concetto fondamentale del framework di primavera, devi impararlo con l'esempio in esecuzione che abbiamo spiegato.