IoC e DI (Inversion of Control e Dependency Injection) – Guida Java Spring

L'Inversion of Control (IoC) è una caratteristica tipica dei framework, che spostano il controllo del flusso dall'applicativo al framework stesso.

Facciamo un esempio per chiarire il concetto: se si crea una GUI attraverso le API swing, il programmatore deve solo preoccuparsi di implementare gli handler degli eventi scatenati dall'utente, quali la pressione di un tasto o l'inserimento di un testo. Al framework viene lasciato il controllo del flusso applicativo, come ad esempio la chiusura e l'apertura delle finestre.

Questo tipo di comportamento viene detto IoC poichè il controllo viene spostato dallo sviluppatore al framework.

Una volta chiarito cosa è l'IoC, vediamo come viene usato in Spring. Tutte le applicazioni sono formate da oggetti che per raggiungere l'obbiettivo prefissato devono collaborare gli uni con gli altri, e quindi inevitabilemente si vengono a formare delle dipendenze. Di norma queste dipendenze vengono risolte da una parte di codice che è atta alla configurazione (tipicamente il costruttore). Supponiamo di dovere implementare una classe per la gestione di una videoteca:

package it.mrwebmaster;

import java.util.ArrayList;
import java.util.List;

public class VideoManager {

  private DvdService dvdService;

  public VideoManager() {
    super();
    /**
     * Configurazione e risoluzione dipendenze
     */
    this.dvdService = new DvdServiceImpl();
  }

  public List<Dvd> getAvalaibleDvdList(){
    /**
     * Recupero la lista dei Dvd
     */
    List<Dvd> dvdList = dvdService.getDvdList();

    /**
     * Ciclo sulla lista dei dvd per trovare 
     * quelli disponibili
     */
    List<Dvd> availabeDvdList = new ArrayList<Dvd>();

    for (Dvd dvd : dvdList) {
      if(dvd.isDisponibile()){
        availabeDvdList.add(dvd);
      }
    }

    return availabeDvdList;
  }
}

In questo esempio la classe VideoManager ha il compito di recuperare la lista dei Dvd non affittati. La lista viene recuperata usando un servizio (DvdService) che recupera la lista di tutti i Dvd, e ciclando sulla lista si trovano i Dvd disponibili. La classe VideoManager, quindi, ha una dipendenza dall'oggetto DvdService, che viene risolta nel costruttore.

Se avessimo usato Spring non ci saremmo dovuti preoccupare di risolvere la dipendeza nel costruttore della classe VideoManager, poichè la dipendenza sarebbe stata risolta da Spring. In Spring, quindi, l'IoC viene usato per invertire il controllo sulla configurazione delle dipendenze. Per questo motivo è stato coniato da Martin Fowler, in un suo famoso articolo, il termine Dependecy Injection (DI), che talvolta viene usato, erroneamente, come sinonimo id IoC. Il concetto di base della DI consiste nell’avere un oggetto separato che si occupi della risoluzione delle dipendenze e della loro inizializzazione.

Nell'esempio seguente la classe Assembler, ha il compito di inizializzare la classe DvdService:

Ci sono tre tipi di Dependecy Injection:

• Interface injection
• Setter injection
• Constructor injection

In Spring, come vedremo più avanti, sono implementate solo la Setter e la Constructor Injection, ma c'è anche la possibilità di inizializzare e creare oggetti attraverso dei Factory Method e dei Factory Object.