Cos'è l'iniezione di dipendenza e l'inversione del controllo nel framework Spring?
"Dependency Injection" e "Inversion of Control" sono spesso menzionati come i principali vantaggi dell'utilizzo del framework Spring per lo sviluppo di framework Web
Qualcuno potrebbe spiegare cosa sia in termini molto semplici con un esempio se possibile?
9 answers
- Spring aiuta nella creazione di applicazioni liberamente accoppiate a causa di Dependency Injection.
- In primavera, gli oggetti definiscono le loro associazioni (dipendenze) e non si preoccupano di come otterranno quelle dipendenze . È responsabilità di Spring fornire le dipendenze richieste per la creazione di oggetti.
Ad esempio: Supponiamo di avere un oggetto Employee e ha una dipendenza dall'oggetto Address. Definiremmo un fagiolo corrispondente a Employee che definirà la sua dipendenza dall'oggetto Address.
Quando Spring tenta di creare un oggetto Employee, vedrà che Employee ha una dipendenza da Address, quindi creerà prima l'oggetto Address (oggetto dipendente) e quindi lo inserirà nell'oggetto Employee.
Inversion of Control (IOC ) e Dependency Injection (DI ) sono usati in modo intercambiabile. CIO è raggiunto attraverso DI. DI è il processo di fornire le dipendenze e IOC è il risultato finale di DI. ( Nota: DI non è l'unico modo per raggiungere il CIO. Ci sono altri modi pure.)
Con DI, la responsabilità di creare oggetti viene spostata dal nostro codice dell'applicazione al contenitore Spring; questo fenomeno è chiamato IOC.
- L'iniezione di dipendenza può essere eseguita mediante iniezione di setter o iniezione di costruttore.
Scriverò la mia semplice comprensione di questi due termini:
For quick understanding just read examples*
Iniezione di dipendenza(DI):
L'iniezione di dipendenza generalmente significa passare un oggetto dipendente come parametro a un metodo, piuttosto che avere il metodo creare l'oggetto dipendente .
Ciò che significa in pratica è che il metodo non ha una dipendenza diretta da una particolare implementazione; qualsiasi implementazione che soddisfi i requisiti può essere passata come parametro.
Con questo gli oggetti raccontano le loro dipendenze.
E la primavera lo rende disponibile.
Ciò porta allo sviluppo di applicazioni liberamente accoppiate.
Quick Example:EMPLOYEE OBJECT WHEN CREATED,IT WILL AUTOMATICALLY CREATE ADDRESS OBJECT (if address is defines as dependency by Employee object)*.<br>
Inversione del contenitore di controllo(CiO):
Questa è una caratteristica comune dei quadri,
IOC gestisce gli oggetti java
– dall'istanziazione alla distruzione attraverso il suo BeanFactory.
-I componenti Java istanziati dal contenitore IoC sono chiamati bean e il contenitore IoC gestisce l'ambito di un bean, gli eventi del ciclo di vita e tutte le funzionalità AOP per le quali è stato configurato e codificato.
QUICK EXAMPLE:Inversion of Control is about getting freedom, more flexibility, and less dependency. When you are using a desktop computer, you are slaved (or say, controlled). You have to sit before a screen and look at it. Using keyboard to type and using mouse to navigate. And a bad written software can slave you even more. If you replaced your desktop with a laptop, then you somewhat inverted control. You can easily take it and move around. So now you can control where you are with your computer, instead of computer controlling it.
Implementando l'Inversione del controllo, un utente software/oggetto ottiene più controlli/opzioni sul software/oggetti, invece di essere controllato o avere meno opzioni.
L'inversione del controllo come linea guida di progettazione ha i seguenti scopi:
C'è un disaccoppiamento dell'esecuzione di un determinato compito da attuazione.
Ogni modulo può concentrarsi su ciò per cui è stato progettato.
I moduli non fanno ipotesi su ciò che fanno gli altri sistemi ma si basano sui loro contratti.
La sostituzione dei moduli non ha alcun effetto collaterale su altri moduli
Terrò le cose astratte qui, puoi visitare i seguenti link per la comprensione dettagliata dell'argomento.
Una buona lettura con l'esempio
Spring: Spring è il contenitore" Inversione di controllo " per la piattaforma Java.
Inversion of Control (IoC): Inversion of Control (IoC) è una pratica di programmazione orientata agli oggetti in cui l'accoppiamento dell'oggetto è limitato in fase di runtime da un oggetto "assembler" e in genere non è conoscibile in fase di compilazione utilizzando l'analisi statica.
Dependency Injection (DI): "Dependency injection è un modello di progettazione software che consente la rimozione di dipendenze hard-coded e consente di cambiali, sia in fase di esecuzione che in fase di compilazione."- wiki.
In Spring Gli oggetti sono accoppiati liberamente, cioè ogni classe è indipendente l'una dall'altra in modo che tutto possa essere testato individualmente. Ma quando si utilizzano quelle classi, una classe può dipendere da altre classi che devono essere istanziate per prime. Quindi, diciamo a spring che la classe A dipende dalla classe B. Quindi, quando si crea bean(come la classe) per la classe A, crea un'istanza della classe B prima di quella della classe A e la inietta nella classe A usando i metodi setter o constructor DI. Cioè, stiamo dicendo primavera la dipendenza in fase di esecuzione. Sono DI. Poiché, stiamo assegnando la responsabilità di creare oggetti(bean), mantenendoli e le loro aggregazioni a Spring invece di codificarli, lo chiamiamo Inversione del controllo(IOC).
Inversione del controllo (IOC):
IoC è un modello di progettazione che descrive l'inversione del flusso di controllo in un sistema, quindi il flusso di esecuzione non è controllato da un pezzo centrale di codice. Ciò significa che i componenti dovrebbero dipendere solo dalle astrazioni di altri componenti e non sono responsabili della gestione della creazione di oggetti dipendenti. Invece, le istanze di oggetti vengono fornite in fase di runtime da un contenitore IoC tramite Dependency Injection (DI).
IoC abilita migliore progettazione del software che facilita il riutilizzo, l'accoppiamento libero e il test facile dei componenti software.
Iniezione di dipendenza (DI):
DI è una tecnica per passare le dipendenze nel costruttore di un oggetto. Se l'oggetto è stato caricato dal contenitore, le sue dipendenze verranno automaticamente fornite dal contenitore. Ciò consente di utilizzare una dipendenza senza dover creare manualmente un'istanza. Questo riduce l'accoppiamento e ti dà una maggiore controllo sulla durata delle istanze oggetto.
Contenitore CiO
Il contenitore IoC è responsabile di istanziare, configurare e assemblare gli oggetti. Il contenitore IoC ottiene informazioni dal file XML e funziona di conseguenza. Le principali attività svolte dal contenitore CiO sono:
- Per istanziare la classe dell'applicazione
- Per configurare l'oggetto
-
Per assemblare le dipendenze tra gli oggetti Esistono due tipi di contenitori IoC. Essi sono:
-
BeanFactory
- ApplicationContext
Dependency Injection (DI)
Dependency Injection (DI) è un modello di progettazione che rimuove la dipendenza dal codice di programmazione in modo che possa essere facile da gestire e testare l'applicazione. L'iniezione di dipendenza rende il nostro codice di programmazione liberamente accoppiato.
Spring framework fornisce due modi per iniettare la dipendenza
- Per Costruttore
- Di Setter metodo
Inversione del controllo- Significa dare il controllo di creare e istanziare i bean di primavera al contenitore IOC di primavera e l'unico lavoro che lo sviluppatore fa è configurare i bean nel file xml di primavera.
Iniezione di dipendenza -
Considera un dipendente di classe
class Employee {
private int id;
private String name;
private Address address;
Employee() {
id = 10;
name="name";
address = new Address();
}
}
E considera l'indirizzo della classe
class Address {
private String street;
private String city;
Address() {
street="test";
city="test1";
}
}
Nel codice precedente i valori della classe address verranno impostati solo quando viene istanziata la classe Employee, che è la dipendenza della classe Address su Classe dipendente. E spring risolve questo problema usando il concetto di iniezione di dipendenza fornendo due modi per iniettare questa dipendenza.
- Iniezione del setter
Metodo Setter nella classe Employee che prende un riferimento della classe Address
public void setAddress(Address addr) {
this.address = addr;
}
- Iniezione costruttore
Costruttore nella classe Employee che accetta Indirizzo
Employee(Address addr) {
this.address = addr;
}
In questo modo i valori della classe Address possono essere impostati indipendentemente utilizzando setter / costruttore iniezione.
Il modo tradizionale di ottenere l'istanza di indirizzo in Employee sarebbe la creazione di una nuova istanza di Address class.La primavera crea tutti gli oggetti dipendenti da noi, quindi non dobbiamo preoccuparci dell'oggetto.
Quindi in primavera dipendiamo solo dal contenitore spring che ci fornisce l'oggetto dependency.
L'inversione del controllo è un principio di progettazione generico dell'architettura software che aiuta a creare framework software riutilizzabili e modulari di facile manutenzione.
È un principio di progettazione in cui il flusso di controllo viene "ricevuto" dalla libreria scritta genericamente o dal codice riutilizzabile.
Per capirlo meglio, vediamo come eravamo abituati a codificare nei nostri primi giorni di codifica. Nei linguaggi procedurali / tradizionali, la logica di business controlla generalmente il flusso del applicazione e "Chiama" il codice/funzioni generici o riutilizzabili. Ad esempio, in una semplice applicazione Console, il mio flusso di controllo è controllato dalle istruzioni del mio programma, che possono includere le chiamate ad alcune funzioni riutilizzabili generali.
print ("Please enter your name:");
scan (&name);
print ("Please enter your DOB:");
scan (&dob);
//More print and scan statements
<Do Something Interesting>
//Call a Library function to find the age (common code)
print Age
Al contrario, con IoC, i Framework sono il codice riutilizzabile che "chiama" la logica di business.
Ad esempio, in un sistema basato su Windows, sarà già disponibile un framework per creare elementi dell'interfaccia utente come pulsanti, menu, finestre e finestre di dialogo scatola. Quando scrivo la logica di business della mia applicazione, sarebbero gli eventi di framework che chiameranno il mio codice di logica di business (quando viene attivato un evento) e NON il contrario.
Sebbene il codice del framework non sia a conoscenza della mia logica di business, saprà comunque come chiamare il mio codice. Ciò si ottiene utilizzando eventi / delegati, callback ecc. Qui il controllo del flusso è "invertito".
Quindi, invece di dipendere il flusso di controllo su oggetti legati staticamente, il flusso dipende dal grafico oggetto generale e le relazioni tra i diversi oggetti.
Dependency Injection è un modello di progettazione che implementa il principio IoC per risolvere le dipendenze degli oggetti.
In parole più semplici, quando stai cercando di scrivere codice, creerai e userai classi diverse. Una classe (Classe A) può utilizzare altre classi (Classe B e/o D). Quindi, le classi B e D sono dipendenze della classe A.
Una semplice analogia sarà una macchina di classe. Un'auto potrebbe dipendere da altre classi come motore, pneumatici e altro ancora.
Dependency Injection suggerisce che invece delle classi dipendenti (Auto di classe qui) che creano le sue dipendenze (Motore di classe e pneumatico di classe), la classe dovrebbe essere iniettata con l'istanza concreta della dipendenza.
Consente di capire con un esempio più pratico. Considera che stai scrivendo il tuo testoeditor. Tra le altre cose, puoi avere un correttore ortografico che fornisce all'utente una possibilità di controllare gli errori di battitura nel suo testo. Semplice l'implementazione di tale codice può essere:
Class TextEditor
{
//Lot of rocket science to create the Editor goes here
EnglishSpellChecker objSpellCheck;
String text;
public void TextEditor()
{
objSpellCheck = new EnglishSpellChecker();
}
public ArrayList <typos> CheckSpellings()
{
//return Typos;
}
}
A prima vista, tutto sembra roseo. L'utente scriverà del testo. Lo sviluppatore acquisirà il testo e chiamerà la funzione Checkspelling e troverà un elenco di errori di battitura che mostrerà all'Utente.
Tutto sembra funzionare alla grande fino a un bel giorno in cui un utente inizia a scrivere il francese nell'Editor.
Per fornire il supporto per più lingue, abbiamo bisogno di avere più controlli ortografici. Probabilmente francese, tedesco, spagnolo ecc.
Qui, abbiamo creato un codice strettamente accoppiato con il controllo ortografico "inglese"strettamente accoppiato con la nostra classe TextEditor, il che significa che la nostra classe TextEditor dipende dall'EnglishSpellChecker o in altre parole EnglishSpellCheker è la dipendenza per TextEditor. Dobbiamo rimuovere questa dipendenza. Inoltre, il nostro editor di testo ha bisogno di un modo per mantenere il riferimento concreto di qualsiasi correttore ortografico basato sulla discrezione dello sviluppatore in fase di esecuzione.
Quindi, come abbiamo visto nell'introduzione di DI, suggerisce che la classe dovrebbe essere iniettata con le sue dipendenze. Quindi, dovrebbe essere responsabilità del codice chiamante iniettare tutte le dipendenze alla classe/codice chiamata. Quindi possiamo ristrutturare il nostro codice come
interface ISpellChecker
{
Arraylist<typos> CheckSpelling(string Text);
}
Class EnglishSpellChecker : ISpellChecker
{
public override Arraylist<typos> CheckSpelling(string Text)
{
//All Magic goes here.
}
}
Class FrenchSpellChecker : ISpellChecker
{
public override Arraylist<typos> CheckSpelling(string Text)
{
//All Magic goes here.
}
}
Nel nostro esempio, la classe TextEditor dovrebbe ricevere l'istanza concreta di tipo ISpellChecker.
Ora, la dipendenza può essere iniettata nel Costruttore, in una proprietà pubblica o in un metodo.
Proviamo a cambiare la nostra classe usando il Costruttore DI. Il cambiato La classe TextEditor sarà simile a:
Class TextEditor
{
ISpellChecker objSpellChecker;
string Text;
public void TextEditor(ISpellChecker objSC)
{
objSpellChecker = objSC;
}
public ArrayList <typos> CheckSpellings()
{
return objSpellChecker.CheckSpelling();
}
}
In modo che il codice chiamante, durante la creazione dell'editor di testo può iniettare il tipo correttore ortografico appropriato per l'istanza del TextEditor.
Puoi leggere l'articolo completo qui