Pattern creazionali - Singleton, Factory Method, Abstract Factory, Builder e Prototype

private static Singleton myInstance = null;
private Singleton() { }
public static Singleton getInstance() {
    if (myInstance == null) myInstance = new Singleton();
    return myInstance;
}

import java.lang.reflect.Constructor;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/** 1) Lazy ingenuo: NON e' thread-safe (il bug delle slide: due thread possono creare due istanze). */
class ConfigIngenua {
    static final AtomicInteger create = new AtomicInteger();
    private static ConfigIngenua istanza;

    private ConfigIngenua() {
        create.incrementAndGet();
        try { Thread.sleep(30); } catch (InterruptedException e) { }   // costruzione "costosa"
    }

    static ConfigIngenua get() {
        if (istanza == null) istanza = new ConfigIngenua();
        return istanza;
    }
}

/** 2) Lazy con metodo synchronized: corretto, ma ogni accesso paga il lucchetto. */
class ConfigSync {
    private static ConfigSync istanza;
    private ConfigSync() { }
    static synchronized ConfigSync get() {
        if (istanza == null) istanza = new ConfigSync();
        return istanza;
    }
}

/** 3) Eager: creata al caricamento della classe (la JVM garantisce il caricamento thread-safe). */
class ConfigEager {
    private static final ConfigEager ISTANZA = new ConfigEager();
    private ConfigEager() { }
    static ConfigEager get() { return ISTANZA; }
}

/** 4) Double-checked locking: volatile e' indispensabile. */
class ConfigDCL {
    static final AtomicInteger create = new AtomicInteger();
    private static volatile ConfigDCL istanza;

    private ConfigDCL() {
        create.incrementAndGet();
        try { Thread.sleep(30); } catch (InterruptedException e) { }
    }

    static ConfigDCL get() {
        ConfigDCL r = istanza;                       // una sola lettura del campo volatile
        if (r == null) {
            synchronized (ConfigDCL.class) {
                r = istanza;
                if (r == null) istanza = r = new ConfigDCL();
            }
        }
        return r;                                    // la versione delle slide dimentica questo return fuori dall'if
    }
}

/** 5) Holder idiom: lazy, senza lucchetti, perche' la classe interna si carica alla prima get(). */
class ConfigHolder {
    private ConfigHolder() { }
    private static class Contenitore { static final ConfigHolder ISTANZA = new ConfigHolder(); }
    static ConfigHolder get() { return Contenitore.ISTANZA; }
}

/** 6) Enum: unica, thread-safe, e immune a riflessione e serializzazione. */
enum ConfigEnum {
    ISTANZA;
    int prestitiMassimi = 5;
}

public class SingletonVarianti {
    /** Lancia n thread che chiamano get() "insieme" e conta quante istanze sono nate. */
    static void provaConcorrente(String nome, Runnable get, AtomicInteger create) throws InterruptedException {
        CountDownLatch via = new CountDownLatch(1);
        Thread[] t = new Thread[8];
        for (int i = 0; i < t.length; i++) {
            t[i] = new Thread(() -> {
                try { via.await(); } catch (InterruptedException e) { }
                get.run();
            });
            t[i].start();
        }
        via.countDown();                              // tutti partono insieme
        for (Thread x : t) x.join();
        System.out.println(nome + ": istanze create = " + create.get());
    }

    public static void main(String[] args) throws Exception {
        provaConcorrente("lazy ingenuo", ConfigIngenua::get, ConfigIngenua.create);
        provaConcorrente("double-checked", ConfigDCL::get, ConfigDCL.create);

        System.out.println("sync stessa istanza?   " + (ConfigSync.get() == ConfigSync.get()));
        System.out.println("eager stessa istanza?  " + (ConfigEager.get() == ConfigEager.get()));
        System.out.println("holder stessa istanza? " + (ConfigHolder.get() == ConfigHolder.get()));

        // La riflessione rompe il costruttore privato (vedi la nota su Java reflection)...
        Constructor<ConfigHolder> k = ConfigHolder.class.getDeclaredConstructor();
        k.setAccessible(true);
        ConfigHolder bis = k.newInstance();
        System.out.println("holder dopo riflessione: ancora unica? " + (bis == ConfigHolder.get()));

        // ...ma non quello di un enum
        try {
            Constructor<ConfigEnum> ke = ConfigEnum.class.getDeclaredConstructor(String.class, int.class);
            ke.setAccessible(true);
            ke.newInstance("COPIA", 1);
        } catch (Exception e) {
            System.out.println("enum: " + e);
        }
    }
}

lazy ingenuo: istanze create = 8
double-checked: istanze create = 1
sync stessa istanza?   true
eager stessa istanza?  true
holder stessa istanza? true
holder dopo riflessione: ancora unica? false
enum: java.lang.IllegalArgumentException: Cannot reflectively create enum objects

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

/** Prodotto: l'interfaccia che il client conosce. */
interface Documento {
    String titolo();
    int giorniPrestito();
}

class Libro implements Documento {
    private final String titolo;
    Libro(String titolo) { this.titolo = titolo; }
    public String titolo() { return titolo; }
    public int giorniPrestito() { return 30; }
    @Override public String toString() { return "Libro(" + titolo + ")"; }
}

class Rivista implements Documento {
    private final String titolo;
    Rivista(String titolo) { this.titolo = titolo; }
    public String titolo() { return titolo; }
    public int giorniPrestito() { return 7; }
    @Override public String toString() { return "Rivista(" + titolo + ")"; }
}

class Dvd implements Documento {
    private final String titolo;
    Dvd(String titolo) { this.titolo = titolo; }
    public String titolo() { return titolo; }
    public int giorniPrestito() { return 3; }
    @Override public String toString() { return "Dvd(" + titolo + ")"; }
}

/** Simple Factory (non e' un pattern GoF): sposta l'if in una classe, ma va modificata a ogni nuovo tipo. */
class SimpleFactoryDocumenti {
    static Documento crea(String tipo, String titolo) {
        switch (tipo) {
            case "libro":   return new Libro(titolo);
            case "rivista": return new Rivista(titolo);
            case "dvd":     return new Dvd(titolo);
            default: throw new IllegalArgumentException("tipo sconosciuto: " + tipo);
        }
    }
}

/** Creator: contiene la parte comune (acquisisci) e DELEGA alle sottoclassi la scelta della classe concreta. */
abstract class Biblioteca {
    private final List<Documento> catalogo = new ArrayList<>();

    /** Il Factory Method: astratto, lo implementa ogni sottoclasse. */
    protected abstract Documento creaDocumento(String tipo, String titolo);

    /** Codice comune, scritto una volta sola e che dipende solo dall'interfaccia Documento. */
    public Documento acquisisci(String tipo, String titolo) {
        Documento d = creaDocumento(tipo, titolo);
        catalogo.add(d);
        System.out.println(getClass().getSimpleName() + " acquisisce " + d + ", prestito " + d.giorniPrestito() + " giorni");
        return d;
    }

    public int dimensione() { return catalogo.size(); }
}

/** ConcreteCreator 1: biblioteca civica, solo libri e riviste. */
class BibliotecaCivica extends Biblioteca {
    @Override protected Documento creaDocumento(String tipo, String titolo) {
        switch (tipo) {
            case "libro":   return new Libro(titolo);
            case "rivista": return new Rivista(titolo);
            default: throw new IllegalArgumentException("la civica non acquisisce: " + tipo);
        }
    }
}

/** ConcreteCreator 2: mediateca, che aggiunge i DVD e allunga i prestiti dei libri. */
class Mediateca extends Biblioteca {
    @Override protected Documento creaDocumento(String tipo, String titolo) {
        if (tipo.equals("dvd")) return new Dvd(titolo);
        if (tipo.equals("libro")) return new Libro(titolo) {          // sottoclasse anonima: 45 giorni
            @Override public int giorniPrestito() { return 45; }
        };
        throw new IllegalArgumentException("la mediateca non acquisisce: " + tipo);
    }
}

public class FactoryMethod {
    public static void main(String[] args) {
        System.out.println(SimpleFactoryDocumenti.crea("dvd", "Metropolis"));

        Biblioteca civica = new BibliotecaCivica();
        civica.acquisisci("libro", "Il barone rampante");
        civica.acquisisci("rivista", "Le Scienze");

        Biblioteca media = new Mediateca();                // il client usa solo il tipo astratto
        media.acquisisci("libro", "Il barone rampante");
        media.acquisisci("dvd", "Metropolis");
        try {
            civica.acquisisci("dvd", "Metropolis");
        } catch (IllegalArgumentException e) {
            System.out.println("errore: " + e.getMessage());
        }
    }
}

Dvd(Metropolis)
BibliotecaCivica acquisisce Libro(Il barone rampante), prestito 30 giorni
BibliotecaCivica acquisisce Rivista(Le Scienze), prestito 7 giorni
Mediateca acquisisce Libro(Il barone rampante), prestito 45 giorni
Mediateca acquisisce Dvd(Metropolis), prestito 3 giorni
errore: la civica non acquisisce: dvd

/** Prodotto A: il documento. */
interface Documento {
    String descrizione();
}

/** Prodotto B: la scheda d'accesso che deve essere coerente con il tipo di documento. */
interface Accesso {
    String istruzioni();
}

class LibroCartaceo implements Documento {
    private final String titolo;
    LibroCartaceo(String titolo) { this.titolo = titolo; }
    public String descrizione() { return "libro cartaceo '" + titolo + "'"; }
}

class SchedaScaffale implements Accesso {
    private final String segnatura;
    SchedaScaffale(String segnatura) { this.segnatura = segnatura; }
    public String istruzioni() { return "ritira al banco, scaffale " + segnatura; }
}

class EBook implements Documento {
    private final String titolo;
    EBook(String titolo) { this.titolo = titolo; }
    public String descrizione() { return "e-book '" + titolo + "' (EPUB)"; }
}

class LicenzaDigitale implements Accesso {
    private final String codice;
    LicenzaDigitale(String codice) { this.codice = codice; }
    public String istruzioni() { return "scarica con la licenza " + codice + " (scade in 14 giorni)"; }
}

/** AbstractFactory: una famiglia di prodotti correlati. */
interface FabbricaSupporto {
    Documento creaDocumento(String titolo);
    Accesso creaAccesso(String riferimento);
}

class FabbricaCartacea implements FabbricaSupporto {
    public Documento creaDocumento(String titolo) { return new LibroCartaceo(titolo); }
    public Accesso creaAccesso(String riferimento) { return new SchedaScaffale(riferimento); }
}

class FabbricaDigitale implements FabbricaSupporto {
    public Documento creaDocumento(String titolo) { return new EBook(titolo); }
    public Accesso creaAccesso(String riferimento) { return new LicenzaDigitale(riferimento); }
}

/** Client: non nomina mai una classe concreta, quindi non puo' mescolare cartaceo e digitale. */
class Catalogatore {
    private final FabbricaSupporto fabbrica;
    Catalogatore(FabbricaSupporto fabbrica) { this.fabbrica = fabbrica; }

    String scheda(String titolo, String riferimento) {
        Documento d = fabbrica.creaDocumento(titolo);
        Accesso a = fabbrica.creaAccesso(riferimento);
        return d.descrizione() + " -> " + a.istruzioni();
    }
}

public class AbstractFactory {
    public static void main(String[] args) {
        // la scelta della famiglia avviene in un punto solo (qui: un argomento, di solito un file di configurazione)
        String supporto = args.length > 0 ? args[0] : "tutti";
        if (!supporto.equals("digitale")) {
            System.out.println(new Catalogatore(new FabbricaCartacea()).scheda("Se questo e' un uomo", "B-12"));
        }
        if (!supporto.equals("cartaceo")) {
            System.out.println(new Catalogatore(new FabbricaDigitale()).scheda("Se questo e' un uomo", "LIC-8841"));
        }
    }
}

libro cartaceo 'Se questo e' un uomo' -> ritira al banco, scaffale B-12
e-book 'Se questo e' un uomo' (EPUB) -> scarica con la licenza LIC-8841 (scade in 14 giorni)

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/** Oggetto complesso e immutabile, con campi obbligatori e facoltativi. */
final class RichiestaRicerca {
    private final String parolaChiave;           // obbligatoria
    private final String autore;                  // facoltativi...
    private final Integer annoDa, annoA;
    private final boolean soloDisponibili;
    private final List<String> lingue;

    private RichiestaRicerca(Builder b) {         // costruttore privato: si passa solo dal Builder
        this.parolaChiave = b.parolaChiave;
        this.autore = b.autore;
        this.annoDa = b.annoDa;
        this.annoA = b.annoA;
        this.soloDisponibili = b.soloDisponibili;
        this.lingue = Collections.unmodifiableList(new ArrayList<>(b.lingue));
    }

    @Override public String toString() {
        return "Ricerca[" + parolaChiave + ", autore=" + autore + ", anni=" + annoDa + ".." + annoA
                + ", soloDisponibili=" + soloDisponibili + ", lingue=" + lingue + "]";
    }

    static class Builder {
        private final String parolaChiave;
        private String autore;
        private Integer annoDa, annoA;
        private boolean soloDisponibili = false;
        private final List<String> lingue = new ArrayList<>();

        Builder(String parolaChiave) {
            if (parolaChiave == null || parolaChiave.isBlank())
                throw new IllegalArgumentException("parola chiave obbligatoria");
            this.parolaChiave = parolaChiave;
        }
        Builder autore(String a)           { this.autore = a; return this; }
        Builder dal(int anno)              { this.annoDa = anno; return this; }
        Builder al(int anno)               { this.annoA = anno; return this; }
        Builder soloDisponibili()          { this.soloDisponibili = true; return this; }
        Builder lingua(String l)           { this.lingue.add(l); return this; }

        RichiestaRicerca build() {
            // le regole tra campi si controllano qui, una volta sola, prima di creare l'oggetto
            if (annoDa != null && annoA != null && annoDa > annoA)
                throw new IllegalStateException("intervallo di anni invertito: " + annoDa + " > " + annoA);
            if (annoA != null && annoA > LocalDate.now().getYear())
                throw new IllegalStateException("anno nel futuro: " + annoA);
            return new RichiestaRicerca(this);
        }
    }
}

public class BuilderEx {
    public static void main(String[] args) {
        // leggibile: ogni valore ha il suo nome (con un costruttore a 6 parametri sarebbe new X("rosa", null, 1980, null, true, ...))
        RichiestaRicerca r = new RichiestaRicerca.Builder("rosa")
                .autore("Eco")
                .dal(1980).al(1990)
                .soloDisponibili()
                .lingua("it").lingua("en")
                .build();
        System.out.println(r);

        System.out.println(new RichiestaRicerca.Builder("fisica").build());   // solo il campo obbligatorio

        try {
            new RichiestaRicerca.Builder("rosa").dal(2000).al(1990).build();
        } catch (IllegalStateException e) {
            System.out.println("errore: " + e.getMessage());
        }
    }
}

Ricerca[rosa, autore=Eco, anni=1980..1990, soloDisponibili=true, lingue=[it, en]]
Ricerca[fisica, autore=null, anni=null..null, soloDisponibili=false, lingue=[]]
errore: intervallo di anni invertito: 2000 > 1990

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/** Prototype: ogni prodotto sa produrre una copia di se' stesso. */
abstract class Documento implements Cloneable {
    protected String titolo;
    protected List<String> paroleChiave = new ArrayList<>();   // oggetto mutabile: serve la copia profonda
    protected int copie = 1;

    @Override public Documento clone() {
        try {
            Documento c = (Documento) super.clone();            // copia superficiale: condivide la lista
            c.paroleChiave = new ArrayList<>(paroleChiave);     // copia profonda della parte mutabile
            return c;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);                        // non succede: implementiamo Cloneable
        }
    }

    @Override public String toString() {
        return getClass().getSimpleName() + "(" + titolo + ", " + paroleChiave + ", copie=" + copie + ")";
    }
}

class Libro extends Documento {
    Libro(String titolo, String... parole) { this.titolo = titolo; for (String p : parole) paroleChiave.add(p); }
}

class Dvd extends Documento {
    Dvd(String titolo, String... parole) { this.titolo = titolo; for (String p : parole) paroleChiave.add(p); }
}

/** Registro di prototipi: crea nuovi documenti clonando quello registrato con il nome richiesto. */
class RegistroPrototipi {
    private final Map<String, Documento> prototipi = new HashMap<>();
    void registra(String nome, Documento p) { prototipi.put(nome, p); }
    Documento crea(String nome) {
        Documento p = prototipi.get(nome);
        if (p == null) throw new IllegalArgumentException("prototipo sconosciuto: " + nome);
        return p.clone();
    }
}

public class PrototypeEx {
    public static void main(String[] args) {
        RegistroPrototipi reg = new RegistroPrototipi();
        reg.registra("manuale", new Libro("Manuale di Java", "java", "programmazione"));
        reg.registra("film", new Dvd("Titolo da definire", "cinema"));

        Documento a = reg.crea("manuale");          // niente "new Libro(...)": la classe concreta e' nascosta
        Documento b = reg.crea("manuale");
        b.titolo = "Manuale di Java, 2a edizione";
        b.paroleChiave.add("seconda-edizione");
        b.copie = 3;
        System.out.println(a);
        System.out.println(b);

        System.out.println("a e b sono lo stesso oggetto? " + (a == b));
        System.out.println("stessa classe? " + (a.getClass() == b.getClass()));
        System.out.println(reg.crea("film"));
    }
}

Libro(Manuale di Java, [java, programmazione], copie=1)
Libro(Manuale di Java, 2a edizione, [java, programmazione, seconda-edizione], copie=3)
a e b sono lo stesso oggetto? false
stessa classe? true
Dvd(Titolo da definire, [cinema], copie=1)