Sommario
Questa è la quarta parte di una serie di tutorial focalizzati sulla revisione degli argomenti di base del linguaggio Java per preparare il lettore all'uso di Spring Framework. La prima parte di questa serie di tutorial può essere ottenuta qui, la seconda parte può essere ottenuta qui e la terza parte qui. In questo tutorial vedremo 2 concetti di base che dobbiamo gestire se vogliamo usare correttamente Spring: Inversion of Control e Dependency Injection.Prima di tutto, voglio chiarire che questi concetti sono spiegati molto meglio da Martin Fowler in questo articolo e tradotti in spagnolo in questa pagina, ma la mia intenzione è cercare di riassumere il concetto per renderlo facilmente comprensibile e risparmiarti un po' di leggere il articolo (anche se siete cordialmente invitati a leggerlo se avete altre domande).
Il termine è relativamente recente ma si tratta di uno schema di programmazione che risale a quei programmi creati utilizzando la pura programmazione sequenziale, dove un singolo programmatore (o gruppo di programmatori) si sedeva per scrivere una serie di passaggi o istruzioni computazionali da eseguire in perfetta sequenza dall'inizio alla fine con l'intenzione di ottenere un risultato finale.
A quel tempo (non credo siano passati molti anni) le chiamate ai metodi e alle librerie provenivano sempre da una fonte centrale che si occupava di manipolare tutte le variabili nello stesso programma. Successivamente sono state sviluppate interfacce grafiche che si occupavano di gestire i dati in ingresso al programma, mentre il flusso principale del programma si occupava di fornire gestori per gli eventi che si verificavano nell'interfaccia grafica (attiva qualcosa quando si clicca, premendo questo tasto , muovendo il mouse, ecc.) mentre l'interfaccia è in un ciclo costante. In questo modo si inverte il controllo del programma, l'interfaccia grafica si occupa di notificare al flusso principale cosa fare e come senza bisogno di sapere esattamente COME si fa.
Se noti, le interfacce in Java possono aiutarti a trasferire il controllo di un'applicazione ad agenti esterni, ma il concetto è applicabile ai thread del demone che aspettano che si verifichi un evento, una classe che è responsabile dell'istanziazione e della consegna di implementazioni di altre classi a il programma (modello di fabbrica) e sostanzialmente qualsiasi modello che consente di trasmettere il controllo del programma a un agente esterno.
È un particolare tipo di Inversion of Control in cui una classe A non sa quale oggetto utilizzerà al momento della compilazione, ma conosce solo le azioni che deve intraprendere con quell'oggetto. Assumiamo la seguente classe (che si basa sulle classi create nel mio tutorial precedente):
Disegnatore di classe pubblica {Piazza pubblica piazza; Fumettista pubblico () {square = new Square (); } public void MasterDraw () {square.Draw (); }} Come vedrai, questa classe "Draftsman" dipende interamente dalla classe "Square" poiché è responsabile del ciclo di vita dell'oggetto quadrato che utilizzerà in seguito. Questo modo di creare una classe "Draftsman" è molto poco pratico perché se in seguito volessimo che il Draftsman disegnasse rettangoli o triangoli, dovremmo modificare il codice di base per farlo.
Invece possiamo creare una classe più riutilizzabile se implementiamo l'interfaccia "Drawable" che abbiamo creato nel tutorial precedente:
public class Disegnatore {Disegno Drawable pubblico; Disegnatore pubblico (Drawable d) {disegno = d; } public void MasterDrawing () {drawing.Drawing (); }} In questo modo gli oggetti della classe "Draftsman" non "controllano" l'oggetto che devono disegnare ma sanno solo che implementa l'interfaccia Drawable e, successivamente, questi oggetti "Draftsman" che creerò nella mia applicazione o che qualcuno altrimenti va utilizzato in un'applicazione che accede alla mia libreria di oggetti, sono perfettamente in grado di ricevere qualsiasi oggetto che implementa l'interfaccia "Drawable".
Nell'esempio precedente stiamo applicando ciò che è noto come "Costruttore Inyection" poiché la dipendenza viene iniettata a livello di costruttore ma puoi iniettare la dipendenza anche tramite i "Setter" oppure, in altri linguaggi di programmazione, puoi iniettare i parametri o le interfacce (In Java non puoi modificare i parametri o le interfacce che accetta un metodo in fase di esecuzione, ma Python, ad esempio, consente ai metodi di accettare parametri senza specificare il tipo dei parametri.)
public class Disegnatore {Disegno Drawable pubblico; public void setDrawing (Drawable d) {drawing = d; } public void MasterDrawing () {drawing.Drawing (); }} Il iniezione di dipendenza essenzialmente permette una separazione delle funzionalità del vostro programma. Questa indipendenza ti consente di testare le tue lezioni senza (vale la pena ripetere) che la tua classe sia legata a nulla. Questa indipendenza è uno dei pezzi chiave da usare Primavera, i componenti dipendono dal framework e non dall'applicazione, puoi creare oggetti che esistono al di fuori della tua applicazione e usarli solo quando ne hai bisogno.
Dal prossimo tutorial inizieremo a lavorare direttamente con Spring e vedrai come tutti i concetti che abbiamo visto finora sono legati al suo funzionamento e ti permetteranno di acquisire le competenze necessarie in breve tempo.
Aspetto i vostri commenti, alla prossima volta!Ti è piaciuto e hai aiutato questo Tutorial?Puoi premiare l'autore premendo questo pulsante per dargli un punto positivo
