Pattern comportamentali - Observer, Strategy, Command, Iterator e Template Method

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/** Observer: chi vuole essere avvisato implementa questa interfaccia. */
interface Osservatore<E> {
    void aggiorna(E evento);
}

/** Subject: tiene la lista degli osservatori, che si registrano e cancellano a runtime. */
class Soggetto<E> {
    // CopyOnWriteArrayList: si puo' (de)registrare mentre si sta notificando, anche da altri thread
    private final List<Osservatore<E>> osservatori = new CopyOnWriteArrayList<>();

    boolean registra(Osservatore<E> o) { return osservatori.add(o); }
    boolean cancella(Osservatore<E> o) { return osservatori.remove(o); }
    int numeroOsservatori() { return osservatori.size(); }

    protected void notifica(E evento) {
        for (Osservatore<E> o : osservatori) o.aggiorna(evento);
    }
}

/** Evento passato agli osservatori (modello "push"). */
class CopiaRestituita {
    final String titolo;
    CopiaRestituita(String titolo) { this.titolo = titolo; }
}

/** ConcreteSubject. */
class Documento extends Soggetto<CopiaRestituita> {
    private final String titolo;
    private boolean inPrestito = true;
    Documento(String titolo) { this.titolo = titolo; }

    void restituisci() {
        inPrestito = false;
        notifica(new CopiaRestituita(titolo));                 // il documento non sa chi ascolta
    }
    boolean inPrestito() { return inPrestito; }
}

/** ConcreteObserver 1. */
class PrenotazioneUtente implements Osservatore<CopiaRestituita> {
    private final String utente;
    PrenotazioneUtente(String utente) { this.utente = utente; }
    public void aggiorna(CopiaRestituita e) {
        System.out.println("mail a " + utente + ": '" + e.titolo + "' e' tornato disponibile");
    }
}

/** ConcreteObserver 2: un tipo di osservatore totalmente diverso, senza modificare Documento. */
class StatisticheRestituzioni implements Osservatore<CopiaRestituita> {
    int restituzioni = 0;
    public void aggiorna(CopiaRestituita e) { restituzioni++; }
}

public class ObserverEx {
    public static void main(String[] args) {
        Documento rosa = new Documento("Il nome della rosa");
        PrenotazioneUtente anna = new PrenotazioneUtente("anna");
        PrenotazioneUtente luca = new PrenotazioneUtente("luca");
        StatisticheRestituzioni stat = new StatisticheRestituzioni();

        rosa.registra(anna);
        rosa.registra(luca);
        rosa.registra(stat);
        rosa.cancella(luca);                                   // luca ha cambiato idea
        rosa.registra(e -> System.out.println("log: restituito " + e.titolo));   // lambda: Osservatore e' funzionale

        rosa.restituisci();
        System.out.println("restituzioni contate: " + stat.restituzioni + ", osservatori: " + rosa.numeroOsservatori());
    }
}

mail a anna: 'Il nome della rosa' e' tornato disponibile
log: restituito Il nome della rosa
restituzioni contate: 1, osservatori: 3

import java.util.Locale;

/** Strategy: una famiglia di algoritmi intercambiabili dietro la stessa interfaccia. */
@FunctionalInterface
interface PoliticaMulta {
    double calcola(int giorniRitardo);
}

class MultaStudente implements PoliticaMulta {
    public double calcola(int g) { return g <= 0 ? 0 : 0.10 * g; }
}

class MultaDocente implements PoliticaMulta {
    public double calcola(int g) { return g <= 7 ? 0 : 0.20 * (g - 7); }   // una settimana di tolleranza
}

class MultaEsterno implements PoliticaMulta {
    public double calcola(int g) { return g <= 0 ? 0 : Math.min(0.50 * g, 15.0); }   // tetto massimo
}

/** Context: usa la strategia senza sapere quale sia, e la si puo' cambiare a runtime. */
class Utente {
    private final String nome;
    private PoliticaMulta politica;
    Utente(String nome, PoliticaMulta politica) { this.nome = nome; this.politica = politica; }
    void cambiaPolitica(PoliticaMulta p) { this.politica = p; }
    String conto(int giorniRitardo) {
        return String.format(Locale.ROOT, "%s: %d giorni di ritardo -> %.2f euro", nome, giorniRitardo, politica.calcola(giorniRitardo));
    }
}

public class StrategyEx {
    public static void main(String[] args) {
        Utente anna = new Utente("anna (studente)", new MultaStudente());
        Utente prof = new Utente("prof (docente)", new MultaDocente());
        Utente ospite = new Utente("ospite", new MultaEsterno());
        System.out.println(anna.conto(10));
        System.out.println(prof.conto(10));
        System.out.println(ospite.conto(40));                   // 20.00 ridotto al tetto di 15.00

        // la strategia e' un'interfaccia con un solo metodo: basta una lambda
        ospite.cambiaPolitica(g -> 0);                           // amnistia
        System.out.println(ospite.conto(40));
    }
}

anna (studente): 10 giorni di ritardo -> 1.00 euro
prof (docente): 10 giorni di ritardo -> 0.60 euro
ospite: 40 giorni di ritardo -> 15.00 euro
ospite: 40 giorni di ritardo -> 0.00 euro

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;

/** Receiver: sa fare il lavoro vero. */
class Magazzino {
    private final Map<String, Integer> copie = new HashMap<>(Map.of("rosa", 2));
    void prendi(String t) {
        if (copie.getOrDefault(t, 0) == 0) throw new IllegalStateException("nessuna copia di " + t);
        copie.merge(t, -1, Integer::sum);
    }
    void rimetti(String t) { copie.merge(t, 1, Integer::sum); }
    int copie(String t) { return copie.getOrDefault(t, 0); }
}

/** Command: la richiesta diventa un oggetto, quindi si puo' memorizzare, mettere in coda e annullare. */
interface Comando {
    void esegui();
    void annulla();
}

class Prestito implements Comando {
    private final Magazzino m; private final String titolo;
    Prestito(Magazzino m, String titolo) { this.m = m; this.titolo = titolo; }
    public void esegui()  { m.prendi(titolo); }
    public void annulla() { m.rimetti(titolo); }
    @Override public String toString() { return "prestito(" + titolo + ")"; }
}

class Restituzione implements Comando {
    private final Magazzino m; private final String titolo;
    Restituzione(Magazzino m, String titolo) { this.m = m; this.titolo = titolo; }
    public void esegui()  { m.rimetti(titolo); }
    public void annulla() { m.prendi(titolo); }
    @Override public String toString() { return "restituzione(" + titolo + ")"; }
}

/** Invoker: esegue i comandi senza conoscerne il tipo e tiene lo storico per l'undo. */
class Sportello {
    private final Deque<Comando> storico = new ArrayDeque<>();
    void esegui(Comando c) {
        c.esegui();                                 // se lancia, il comando non entra nello storico
        storico.push(c);
        System.out.println("eseguito " + c);
    }
    void annullaUltimo() {
        if (storico.isEmpty()) { System.out.println("niente da annullare"); return; }
        Comando c = storico.pop();
        c.annulla();
        System.out.println("annullato " + c);
    }
}

public class CommandEx {
    public static void main(String[] args) {
        Magazzino m = new Magazzino();
        Sportello s = new Sportello();
        s.esegui(new Prestito(m, "rosa"));
        s.esegui(new Prestito(m, "rosa"));
        System.out.println("copie: " + m.copie("rosa"));
        try {
            s.esegui(new Prestito(m, "rosa"));      // finite
        } catch (IllegalStateException e) {
            System.out.println("errore: " + e.getMessage());
        }
        s.annullaUltimo();
        s.annullaUltimo();
        System.out.println("copie dopo due undo: " + m.copie("rosa"));
        s.annullaUltimo();
    }
}

eseguito prestito(rosa)
eseguito prestito(rosa)
copie: 0
errore: nessuna copia di rosa
annullato prestito(rosa)
annullato prestito(rosa)
copie dopo due undo: 2
niente da annullare

import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;

class Documento {
    final String titolo; final boolean disponibile;
    Documento(String titolo, boolean disponibile) { this.titolo = titolo; this.disponibile = disponibile; }
    @Override public String toString() { return titolo + (disponibile ? "" : " (in prestito)"); }
}

/** Aggregate: espone un Iterator e non rivela come i documenti sono memorizzati (qui: array). */
class Scaffale implements Iterable<Documento> {
    private Documento[] dati = new Documento[2];
    private int n = 0;
    private int modifiche = 0;                                  // serve all'iteratore fail-fast

    void aggiungi(Documento d) {
        if (n == dati.length) dati = java.util.Arrays.copyOf(dati, n * 2);
        dati[n++] = d;
        modifiche++;
    }

    /** Iterator (classe interna: vede lo stato dell'aggregato). */
    @Override public Iterator<Documento> iterator() {
        return new Iterator<Documento>() {
            private int pos = 0;
            private final int attese = modifiche;

            public boolean hasNext() { return pos < n; }

            public Documento next() {
                if (attese != modifiche) throw new ConcurrentModificationException();
                if (!hasNext()) throw new NoSuchElementException();
                return dati[pos++];
            }
        };
    }

    /** Un secondo modo di scorrere lo stesso aggregato: solo i documenti disponibili. */
    Iterable<Documento> soloDisponibili() {
        return () -> new Iterator<Documento>() {
            private final Iterator<Documento> it = iterator();
            private Documento prossimo = avanza();

            private Documento avanza() {
                while (it.hasNext()) { Documento d = it.next(); if (d.disponibile) return d; }
                return null;
            }
            public boolean hasNext() { return prossimo != null; }
            public Documento next() {
                if (prossimo == null) throw new NoSuchElementException();
                Documento r = prossimo; prossimo = avanza(); return r;
            }
        };
    }
}

public class IteratorEx {
    public static void main(String[] args) {
        Scaffale s = new Scaffale();
        s.aggiungi(new Documento("Il nome della rosa", true));
        s.aggiungi(new Documento("Il pendolo di Foucault", false));
        s.aggiungi(new Documento("Baudolino", true));

        for (Documento d : s) System.out.println("tutti:        " + d);          // il for-each usa iterator()
        for (Documento d : s.soloDisponibili()) System.out.println("disponibili:  " + d);

        try {
            for (Documento d : s) s.aggiungi(new Documento("Nuovo", true));      // modifica durante la scansione
        } catch (ConcurrentModificationException e) {
            System.out.println("ConcurrentModificationException: scaffale modificato durante la scansione");
        }
    }
}

tutti:        Il nome della rosa
tutti:        Il pendolo di Foucault (in prestito)
tutti:        Baudolino
disponibili:  Il nome della rosa
disponibili:  Baudolino
ConcurrentModificationException: scaffale modificato durante la scansione

/** Template Method: lo scheletro dell'algoritmo e' fisso, i passi variabili sono metodi astratti o hook. */
abstract class ProceduraPrestito {
    /** Il template method: final, nessuna sottoclasse puo' cambiare l'ordine dei passi. */
    public final boolean esegui(String utente, String titolo) {
        System.out.println("--- " + getClass().getSimpleName() + ": " + utente + " chiede '" + titolo + "'");
        if (!verificaUtente(utente)) { System.out.println("utente non abilitato"); return false; }
        if (!verificaDisponibilita(titolo)) { System.out.println("non disponibile"); return false; }
        registra(utente, titolo);                       // passo astratto: ogni sottoclasse lo realizza
        dopoRegistrazione(utente, titolo);              // hook: facoltativo, per default non fa nulla
        return true;
    }

    protected boolean verificaUtente(String utente) { return !utente.isBlank(); }        // comune
    protected abstract boolean verificaDisponibilita(String titolo);
    protected abstract void registra(String utente, String titolo);
    protected void dopoRegistrazione(String utente, String titolo) { }                   // hook
}

class PrestitoLibro extends ProceduraPrestito {
    private int copie = 1;
    @Override protected boolean verificaDisponibilita(String titolo) { return copie > 0; }
    @Override protected void registra(String utente, String titolo) {
        copie--;
        System.out.println("libro registrato, scadenza tra 30 giorni");
    }
}

class PrestitoDvd extends ProceduraPrestito {
    @Override protected boolean verificaUtente(String utente) {              // ridefinisce un passo comune
        return super.verificaUtente(utente) && !utente.startsWith("minore");
    }
    @Override protected boolean verificaDisponibilita(String titolo) { return true; }
    @Override protected void registra(String utente, String titolo) {
        System.out.println("dvd registrato, scadenza tra 3 giorni");
    }
    @Override protected void dopoRegistrazione(String utente, String titolo) {   // usa l'hook
        System.out.println("promemoria SMS a " + utente);
    }
}

public class TemplateEx {
    public static void main(String[] args) {
        ProceduraPrestito libro = new PrestitoLibro();
        libro.esegui("anna", "Baudolino");
        libro.esegui("luca", "Baudolino");              // nessuna copia
        ProceduraPrestito dvd = new PrestitoDvd();
        dvd.esegui("anna", "Metropolis");
        dvd.esegui("minore-12", "Metropolis");
    }
}

--- PrestitoLibro: anna chiede 'Baudolino'
libro registrato, scadenza tra 30 giorni
--- PrestitoLibro: luca chiede 'Baudolino'
non disponibile
--- PrestitoDvd: anna chiede 'Metropolis'
dvd registrato, scadenza tra 3 giorni
promemoria SMS a anna
--- PrestitoDvd: minore-12 chiede 'Metropolis'
utente non abilitato