Nell’ ingegneria del software, si dice Lazy initialization (inizializzazione pigra) la tattica di istanziare un oggetto, inizializzare una variabile o eseguire un processo solo nel momento in cui tale operazione è richiesta.

Tipicamente, questo si ottiene memorizzando in un flag l’avvenimento di un determinato processo. Ogni volta che si verifica un certo evento, viene esaminato il flag. Se questo è impostato a zero (false), si continua, altrimenti si inizializza una certa variabile o si istanzia un certo oggetto.

Lazy initialization

Dal punto di vista dei design pattern, la lazy initialization viene usata molto spesso con un factory method. Questo permette di combinare 3 idee:

  • Usare un factory method per instanziare una classe;
  • Memorizzare l’istanza di una mappa, in modo tale da poter riprendere la stessa istanza la volta successiva che si richiede la stessa con certi parametri (singleton);
  • Usare questa tecnica per istanziare un oggetto solamente la prima volta che è richiesto.

 

IMPLEMENTAZIONE LAZY INITIALIZATION

Step 1: Creiamo la classe Carta che utilizzerà la Lazy Initialization

import java.util.*;

public class Carta {

    //Mappatura tra carta (String) e la sua istanza (Carta)
    private static Map<String, Carta> carte = new HashMap<String, Carta>();

    //Contiene i valori dell'istanza corrente
    private String seme;
    private String valore;

    public String getSeme() {
        return seme;
    }

    public String getValore() {
        return valore;
    }

    //Rendiamo il costruttore privato per forzare l'uso del metodo factory.
    private Carta(String seme, String valore){
        this.seme=seme;
        this.valore=valore;
        carte.put(seme, this);
        carte.put(valore, this);
    }

     //Metodo Lazy con pattern Factory: recupera un'istanza di Carta
     // se presente, altrimenti istanzia un nuovo oggetto.
     public static Carta getCarta(String seme, String valore) {
        System.out.println("[CARTA]: getCarta::start()");
        Carta carta;
        if (carte.containsKey(seme) && (carte.containsKey(valore))){
            System.out.println("[CARTA]: getCarta::Carta trovata!");
            carta = carte.get(seme); // recupera l'istanza di quel tipo
        } else {
            System.out.println("[CARTA]: getCarta::Carta non trovata! Nuovo oggetto creato.");
            carta = new Carta(seme, valore); // inizializzazione lazy (pigra)
        }
         System.out.println("[CARTA]: getCarta::end()");
        return carta;
    }
}

Step 2: Creiamo il Main

public class Main {
    public static void main(String args[]) {
        String semeCarta = "Cuori";
        String valoreCarta = "Sette";
        Carta carta1;
        Carta carta2;
        Carta carta3;

        carta1 = Carta.getCarta(semeCarta,valoreCarta);
        System.out.println("[MAIN]: CARTA1::SEME = "+carta1.getSeme());
        System.out.println("[MAIN]: CARTA1::VALORE = "+carta1.getValore()+"\n");
        carta2 = Carta.getCarta(semeCarta,valoreCarta);
        System.out.println("[MAIN]: CARTA2::SEME = "+carta2.getSeme());
        System.out.println("[MAIN]: CARTA2::VALORE = "+carta2.getValore()+"\n");

        valoreCarta = "Cinque";
        carta3 = Carta.getCarta(semeCarta,valoreCarta);
        System.out.println("[MAIN]: CARTA3::SEME = "+carta3.getSeme());
        System.out.println("[MAIN]: CARTA3::VALORE = "+carta3.getValore());

    }
}

Step 3: Output

[CARTA]: getCarta::start()
[CARTA]: getCarta::Carta non trovata! Nuovo oggetto creato.
[CARTA]: getCarta::end()
[MAIN]: CARTA1::SEME = Cuori
[MAIN]: CARTA1::VALORE = Sette

[CARTA]: getCarta::start()
[CARTA]: getCarta::Carta trovata!
[CARTA]: getCarta::end()
[MAIN]: CARTA2::SEME = Cuori
[MAIN]: CARTA2::VALORE = Sette

[CARTA]: getCarta::start()
[CARTA]: getCarta::Carta non trovata! Nuovo oggetto creato.
[CARTA]: getCarta::end()
[MAIN]: CARTA3::SEME = Cuori
[MAIN]: CARTA3::VALORE = Cinque

 

LINK UTILI