Pattern strutturali - Adapter, Decorator, Composite, Facade e Proxy

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

/** Target: l'interfaccia che il client della biblioteca si aspetta. */
interface RicercaCatalogo {
    List<String> cercaTitoli(String parolaChiave);
}

/** Adaptee: un vecchio catalogo che non possiamo modificare (niente sorgenti, o non e' nostro). */
class CatalogoLegacy {
    private final String[] titoli = {"Il nome della rosa", "Il pendolo di Foucault", "La rosa purpurea del Cairo"};

    /** Restituisce un array separato da ';' e fa distinzione tra maiuscole e minuscole. */
    public String trova(String testo) {
        StringBuilder sb = new StringBuilder();
        for (String t : titoli) if (t.contains(testo)) sb.append(sb.length() == 0 ? "" : ";").append(t);
        return sb.toString();
    }
}

/** Adapter di OGGETTO: contiene l'adaptee (composizione). Puo' adattare anche sottoclassi di CatalogoLegacy. */
class AdapterOggetto implements RicercaCatalogo {
    private final CatalogoLegacy adaptee;
    AdapterOggetto(CatalogoLegacy adaptee) { this.adaptee = adaptee; }

    public List<String> cercaTitoli(String parolaChiave) {
        String grezzo = adaptee.trova(parolaChiave);
        List<String> out = new ArrayList<>();
        if (!grezzo.isEmpty()) for (String t : grezzo.split(";")) out.add(t);
        return out;
    }
}

/** Adapter di CLASSE: eredita l'adaptee (extends) e implementa il target (implements). */
class AdapterClasse extends CatalogoLegacy implements RicercaCatalogo {
    public List<String> cercaTitoli(String parolaChiave) {
        String grezzo = trova(parolaChiave);                  // chiama il metodo ereditato
        List<String> out = new ArrayList<>();
        if (!grezzo.isEmpty()) for (String t : grezzo.split(";")) out.add(t);
        return out;
    }
}

/** Client: conosce solo RicercaCatalogo. */
class Sportello {
    static void stampa(RicercaCatalogo r, String q) {
        System.out.println("'" + q + "' -> " + r.cercaTitoli(q));
    }
}

public class AdapterEx {
    public static void main(String[] args) {
        RicercaCatalogo a = new AdapterOggetto(new CatalogoLegacy());
        RicercaCatalogo b = new AdapterClasse();
        Sportello.stampa(a, "rosa");
        Sportello.stampa(b, "rosa");
        Sportello.stampa(a, "xyz");
    }
}

'rosa' -> [Il nome della rosa, La rosa purpurea del Cairo]
'rosa' -> [Il nome della rosa, La rosa purpurea del Cairo]
'xyz' -> []

import java.util.Locale;

/** Component: tutto cio' che ha un costo di prestito. */
interface Prestito {
    double costo();
    String descrizione();
}

/** ConcreteComponent. */
class PrestitoBase implements Prestito {
    private final String titolo;
    PrestitoBase(String titolo) { this.titolo = titolo; }
    public double costo() { return 1.00; }
    public String descrizione() { return "prestito di '" + titolo + "'"; }
}

/** Decorator: ha lo stesso tipo del Component e CONTIENE un Component. */
abstract class PrestitoDecorato implements Prestito {
    protected final Prestito interno;
    PrestitoDecorato(Prestito interno) { this.interno = interno; }
    public double costo() { return interno.costo(); }               // per default inoltra
    public String descrizione() { return interno.descrizione(); }
}

class ConAssicurazione extends PrestitoDecorato {
    ConAssicurazione(Prestito p) { super(p); }
    @Override public double costo() { return interno.costo() + 0.50; }
    @Override public String descrizione() { return interno.descrizione() + " + assicurazione"; }
}

class ConConsegna extends PrestitoDecorato {
    ConConsegna(Prestito p) { super(p); }
    @Override public double costo() { return interno.costo() + 2.00; }
    @Override public String descrizione() { return interno.descrizione() + " + consegna a domicilio"; }
}

class ScontoStudenti extends PrestitoDecorato {
    ScontoStudenti(Prestito p) { super(p); }
    @Override public double costo() { return interno.costo() * 0.5; }   // l'ordine dei decoratori conta
    @Override public String descrizione() { return interno.descrizione() + " - sconto studenti"; }
}

public class DecoratorEx {
    static void stampa(Prestito p) {
        System.out.println(String.format(Locale.ROOT, "%.2f  %s", p.costo(), p.descrizione()));
    }

    public static void main(String[] args) {
        Prestito base = new PrestitoBase("Il nome della rosa");
        stampa(base);
        stampa(new ConAssicurazione(base));
        stampa(new ConConsegna(new ConAssicurazione(base)));
        // sconto applicato prima o dopo la consegna: risultati diversi
        stampa(new ConConsegna(new ScontoStudenti(base)));
        stampa(new ScontoStudenti(new ConConsegna(base)));

        // il decoratore del JDK piu' noto: tutte le classi di java.io
        // new BufferedReader(new InputStreamReader(System.in))
    }
}

1.00  prestito di 'Il nome della rosa'
1.50  prestito di 'Il nome della rosa' + assicurazione
3.50  prestito di 'Il nome della rosa' + assicurazione + consegna a domicilio
2.50  prestito di 'Il nome della rosa' - sconto studenti + consegna a domicilio
1.50  prestito di 'Il nome della rosa' + consegna a domicilio - sconto studenti

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

/** Component: foglie e contenitori si usano nello stesso modo. */
interface Voce {
    String nome();
    int numeroDocumenti();
    double valore();
    void stampa(String rientro);
}

/** Leaf. */
class Documento implements Voce {
    private final String titolo;
    private final double prezzo;
    Documento(String titolo, double prezzo) { this.titolo = titolo; this.prezzo = prezzo; }
    public String nome() { return titolo; }
    public int numeroDocumenti() { return 1; }
    public double valore() { return prezzo; }
    public void stampa(String rientro) { System.out.println(rientro + "- " + titolo + " (" + prezzo + ")"); }
}

/** Composite: contiene altre Voce (documenti o altre sezioni) e calcola ricorsivamente. */
class Sezione implements Voce {
    private final String nome;
    private final List<Voce> figli = new ArrayList<>();
    Sezione(String nome) { this.nome = nome; }

    Sezione aggiungi(Voce v) { figli.add(v); return this; }

    public String nome() { return nome; }
    public int numeroDocumenti() {
        int n = 0;
        for (Voce v : figli) n += v.numeroDocumenti();
        return n;
    }
    public double valore() {
        double s = 0;
        for (Voce v : figli) s += v.valore();
        return s;
    }
    public void stampa(String rientro) {
        System.out.println(rientro + "+ " + nome + " [" + numeroDocumenti() + " documenti, valore " + valore() + "]");
        for (Voce v : figli) v.stampa(rientro + "    ");
    }
}

public class CompositeEx {
    public static void main(String[] args) {
        Sezione narrativa = new Sezione("Narrativa")
                .aggiungi(new Documento("Il nome della rosa", 12.0))
                .aggiungi(new Documento("Il barone rampante", 9.5));
        Sezione scienze = new Sezione("Scienze")
                .aggiungi(new Documento("Fisica 1", 40.0))
                .aggiungi(new Sezione("Matematica")
                        .aggiungi(new Documento("Analisi 1", 38.0))
                        .aggiungi(new Documento("Algebra lineare", 30.0)));
        Sezione biblioteca = new Sezione("Biblioteca").aggiungi(narrativa).aggiungi(scienze);

        biblioteca.stampa("");                                   // il client non distingue foglie e sezioni
        System.out.println("totale: " + biblioteca.numeroDocumenti() + " documenti");
    }
}

+ Biblioteca [5 documenti, valore 129.5]
    + Narrativa [2 documenti, valore 21.5]
        - Il nome della rosa (12.0)
        - Il barone rampante (9.5)
    + Scienze [3 documenti, valore 108.0]
        - Fisica 1 (40.0)
        + Matematica [2 documenti, valore 68.0]
            - Analisi 1 (38.0)
            - Algebra lineare (30.0)
totale: 5 documenti

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/** Sottosistema: quattro classi con le loro interfacce. */
class Utenti {
    private final Set<String> iscritti = new HashSet<>(Set.of("anna", "luca"));
    boolean esiste(String u) { return iscritti.contains(u); }
}

class Catalogo {
    private final Map<String, Integer> copie = new HashMap<>(Map.of("rosa", 1, "pendolo", 0));
    boolean disponibile(String titolo) { return copie.getOrDefault(titolo, 0) > 0; }
    void prelevaCopia(String titolo) { copie.merge(titolo, -1, Integer::sum); }
}

class Prestiti {
    private final Map<String, String> inPrestito = new HashMap<>();   // titolo -> utente
    void registra(String utente, String titolo) { inPrestito.put(titolo, utente); }
    int conta() { return inPrestito.size(); }
}

class Notifiche {
    void invia(String utente, String testo) { System.out.println("  [mail a " + utente + "] " + testo); }
}

/** Facade: un'unica operazione di alto livello che coordina il sottosistema. */
class Sportello {
    private final Utenti utenti = new Utenti();
    private final Catalogo catalogo = new Catalogo();
    private final Prestiti prestiti = new Prestiti();
    private final Notifiche notifiche = new Notifiche();

    /** Il client chiama solo questo metodo, senza conoscere i quattro oggetti. */
    boolean prendiInPrestito(String utente, String titolo) {
        if (!utenti.esiste(utente)) { System.out.println("utente sconosciuto: " + utente); return false; }
        if (!catalogo.disponibile(titolo)) {
            notifiche.invia(utente, "'" + titolo + "' non e' disponibile");
            return false;
        }
        catalogo.prelevaCopia(titolo);
        prestiti.registra(utente, titolo);
        notifiche.invia(utente, "prestito di '" + titolo + "' registrato");
        return true;
    }

    int prestitiAttivi() { return prestiti.conta(); }
}

public class FacadeEx {
    public static void main(String[] args) {
        Sportello s = new Sportello();
        System.out.println(s.prendiInPrestito("anna", "rosa"));
        System.out.println(s.prendiInPrestito("luca", "rosa"));       // nessuna copia rimasta
        System.out.println(s.prendiInPrestito("piero", "pendolo"));   // utente sconosciuto
        System.out.println("prestiti attivi: " + s.prestitiAttivi());
    }
}

  [mail a anna] prestito di 'rosa' registrato
true
  [mail a luca] 'rosa' non e' disponibile
false
utente sconosciuto: piero
false
prestiti attivi: 1

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

/** Subject: interfaccia comune a oggetto reale e proxy. */
interface Catalogo {
    String descrivi(String titolo);
    void elimina(String titolo);
}

/** RealSubject: il catalogo "remoto", lento da contattare. */
class CatalogoRemoto implements Catalogo {
    static int chiamate = 0;
    public String descrivi(String titolo) {
        chiamate++;
        return "scheda completa di '" + titolo + "'";
    }
    public void elimina(String titolo) { System.out.println("  eliminato '" + titolo + "' dal server"); }
}

/** Proxy virtuale + di cache: crea l'oggetto reale solo se serve e non ripete le richieste uguali. */
class CatalogoCache implements Catalogo {
    private CatalogoRemoto reale;                              // creato alla prima richiesta (lazy)
    private final Map<String, String> cache = new HashMap<>();

    public String descrivi(String titolo) {
        return cache.computeIfAbsent(titolo, t -> {
            if (reale == null) reale = new CatalogoRemoto();
            return reale.descrivi(t);
        });
    }
    public void elimina(String titolo) {
        if (reale == null) reale = new CatalogoRemoto();
        cache.remove(titolo);
        reale.elimina(titolo);
    }
}

/** Proxy di protezione: lascia passare le operazioni solo a chi ha il ruolo giusto. */
class CatalogoProtetto implements Catalogo {
    private final Catalogo reale;
    private final String ruolo;
    CatalogoProtetto(Catalogo reale, String ruolo) { this.reale = reale; this.ruolo = ruolo; }
    public String descrivi(String titolo) { return reale.descrivi(titolo); }
    public void elimina(String titolo) {
        if (!ruolo.equals("bibliotecario")) throw new SecurityException("ruolo '" + ruolo + "' non autorizzato");
        reale.elimina(titolo);
    }
}

public class ProxyEx {
    public static void main(String[] args) {
        Catalogo c = new CatalogoCache();
        System.out.println(c.descrivi("rosa"));
        System.out.println(c.descrivi("rosa"));                 // risposta dalla cache
        System.out.println("chiamate al server: " + CatalogoRemoto.chiamate);

        Catalogo p = new CatalogoProtetto(c, "studente");
        try { p.elimina("rosa"); } catch (SecurityException e) { System.out.println("negato: " + e.getMessage()); }
        new CatalogoProtetto(c, "bibliotecario").elimina("rosa");

        // Proxy dinamico del JDK (usa la riflessione): un solo handler per qualsiasi interfaccia
        InvocationHandler registro = (proxy, metodo, argomenti) -> {
            System.out.println("  [log] chiamato " + metodo.getName() + "(" + argomenti[0] + ")");
            return metodo.invoke(c, argomenti);
        };
        Catalogo logged = (Catalogo) Proxy.newProxyInstance(
                Catalogo.class.getClassLoader(), new Class<?>[]{Catalogo.class}, registro);
        System.out.println(logged.descrivi("pendolo"));
    }
}

scheda completa di 'rosa'
scheda completa di 'rosa'
chiamate al server: 1
negato: ruolo 'studente' non autorizzato
  eliminato 'rosa' dal server
  [log] chiamato descrivi(pendolo)
scheda completa di 'pendolo'