Design patterns in Java

Lo sviluppo di software è una disciplina tanto artistica quanto tecnica, che richiede non solo capacità di codifica ma anche una progettazione attenta. I design patterns, o “modelli di progettazione”, sono soluzioni consolidate a problemi ricorrenti nello sviluppo software. Questi modelli offrono un linguaggio comune tra gli sviluppatori e servono come strumenti per creare software in modo efficiente e mantenibile. In questo articolo, esploreremo due dei design patterns più fondamentali in Java: il Singleton e il Factory.

Cos’è un design pattern?

I design pattern sono una componente fondamentale nell’architettura del software, fornendo una struttura ripetibile e ottimizzata per risolvere problemi di progettazione comuni. I pattern emergono dalle esperienze di sviluppo di software nel corso di molteplici contesti e progetti. Essi aiutano a evitare soluzioni ad hoc che possono essere meno efficienti e più difficili da comprendere e mantenere.

Classificazione dei Design Patterns

I design patterns sono tipicamente divisi in tre categorie principali:

1. Creazionali:Si concentrano sulla logica di creazione degli oggetti. Mirano a rendere un sistema indipendente da come gli oggetti in esso sono creati, composti e rappresentati. Esempi includono il Singleton, Factory Method, Abstract Factory, Builder e Prototype.
2. Strutturali: Riguardano la composizione di classi e oggetti per formare strutture più grandi. Questi pattern facilitano la progettazione assicurando che le modifiche in una parte del sistema richiedano modifiche minime in altre parti. Esempi includono Adapter, Decorator, Facade, Composite e Flyweight.
3. Comportamentali: Si concentrano sull’assegnazione di responsabilità tra gli oggetti. Cosa fa un sistema non dipende solo da come gli oggetti sono composti, ma anche da come comunicano tra loro. Esempi includono Strategy, Observer, Command, Iterator e State.

Esempi di Design Patterns in Java

Singleton

Il Singleton, come accennato, garantisce che una classe abbia solo una singola istanza e fornisce un punto di accesso globale a questa istanza.

Esempio di Singleton in Java:

public class DatabaseConnector {
    private static DatabaseConnector instance;

    private DatabaseConnector() {
        // Inizializzazione della connessione al database
    }

    public static synchronized DatabaseConnector getInstance() {
        if (instance == null) {
            instance = new DatabaseConnector();
        }
        return instance;
    }

    // Metodi per interagire con il database
}

Il pattern Singleton è utile in diverse situazioni, ma deve essere usato con cautela perché può portare a problemi di design se usato impropriamente. Ecco alcune situazioni in cui l’uso di Singleton potrebbe essere giustificato:

• Controllo delle Risorse Condivise: Quando si ha bisogno di un controllo rigoroso su una risorsa condivisa. Ad esempio, la gestione della connessione a un database può essere un buon candidato per il pattern Singleton per evitare l’apertura di connessioni multiple inutilmente.
• Configurazione Globale: Il Singleton può essere utilizzato per memorizzare la configurazione che deve essere accessibile globalmente e rimanere consistente in tutta l’applicazione, come le impostazioni di configurazione caricate da un file.
• Logging: Un logger è spesso implementato come un Singleton per evitare la sovrapposizione o la duplicazione dei messaggi di log quando diverse parti dell’applicazione cercano di accedere allo stesso file di log.
• Driver Hardware o Gestione delle Connessioni: Se l’applicazione necessita di un punto di accesso unico a un driver hardware o a una connessione (come una connessione seriale a un dispositivo fisico), il Singleton può garantire che il driver non sia inizializzato più volte.
• Pool di Oggetti: Per la gestione di un pool di risorse, come thread o connessioni, dove è necessario un punto di accesso centralizzato e controllato.
• Servizi di Cache: Quando si implementano servizi di cache, il Singleton può essere utile per mantenere un unico punto di riferimento per la cache, assicurandosi che la cache sia unica e globale.
• Servizi di Factory con Stato: In alcuni casi, potrebbe essere necessario che una factory mantenga uno stato durante la creazione di oggetti; un Singleton potrebbe essere adatto per conservare tale stato.

Factory Method

Il Factory Method offre un modo per delegare la logica di istanziazione agli eredi della classe base. La classe base in un modello factory non crea direttamente oggetti; invece, chiama un metodo factory per farlo.

Esempio di Factory Method in Java:

public abstract class Animal {
    public abstract String speak();
}

public class Dog extends Animal {
    @Override
    public String speak() {
        return "Bark";
    }
}

public class Cat extends Animal {
    @Override
    public String speak() {
        return "Meow";
    }
}

public class AnimalFactory {
    public Animal createAnimal(String type) {
        if (type.equalsIgnoreCase("dog")) {
            return new Dog();
        } else if (type.equalsIgnoreCase("cat")) {
            return new Cat();
        } else {
            throw new IllegalArgumentException("Unknown animal type");
        }
    }
}

Questo pattern è particolarmente utile quando ci sono interfacce comuni per diversi compiti, ma è necessaria la flessibilità nella creazione concreta degli oggetti.

L’uso è consigliato:

• Quando la Creazione di Oggetti Richiede Logica Complessa: Se la creazione di un oggetto non è solo una questione di inizializzazione ma richiede una logica decisionale, il Factory Method permette di isolare questa logica all’interno di una classe o metodo dedicato.
• Quando c’è Bisogno di Flessibilità nella Creazione di Oggetti: Se il tuo codice deve essere estensibile, in modo che possa aggiungere nuove classi di prodotti con piccole modifiche o senza alcuna modifica al codice cliente, il Factory Method è una buona scelta.

Adapter

L’Adapter consente di interfacciare due sistemi incompatibili. L’Adapter converte l’interfaccia di una classe in un’altra interfaccia attesa dai client.

Esempio di Adapter in Java:

public interface EuropeanPlug {
    void fitEuropeanSocket();
}

public class AmericanPlug {
    public void fitAmericanSocket() {
        System.out.println("Fitting American plug into American socket.");
    }
}

public class PlugAdapter implements EuropeanPlug {
    private AmericanPlug americanPlug;

    public PlugAdapter(AmericanPlug americanPlug) {
        this.americanPlug = americanPlug;
    }

    @Override
    public void fitEuropeanSocket() {
        americanPlug.fitAmericanSocket();
    }
}

L’Adapter funge da ponte tra il codice client e le classi che hanno interfacce diverse, traducendo le richieste del codice client in un formato che la classe adattata può comprendere.

Quando Usare l’Adapter

• Integrazione di Terze Parti: Quando il codice deve interagire con una libreria esterna o un sistema che ha un’interfaccia incompatibile con quella attuale del sistema. L’Adapter può tradurre le chiamate tra il sistema e la libreria di terze parti.
• Riuso del Codice Esistente: Se c’è del codice esistente o una libreria che fa quello che serve, ma la sua interfaccia non corrisponde a quella che il sistema corrente si aspetta, un Adapter può essere usato per riusare questo codice senza riscriverlo.

• Refactoring: Quando stai rifattorizzando parti di un sistema che non possono essere modificate direttamente, forse perché sono state distribuite in librerie o perché altre parti del sistema dipendono da esse, puoi usare un Adapter per fornire l’interfaccia richiesta senza toccare il codice originale.
• Transizione tra Diverse Piattaforme: Quando stai migrando o integrando sistemi da piattaforme diverse e hai bisogno di standardizzare le comunicazioni tra di essi, gli Adapter possono fornire un mezzo per uniformare le interazioni.

Observer

L’Observer è un pattern comportamentale che definisce una dipendenza uno-a-molti tra oggetti in modo che quando un oggetto cambia stato, tutti i suoi dipendenti vengono notificati e aggiornati automaticamente.

Esempio di Observer in Java:

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

public class NewsAgency {
    private String news;
    private List<Channel> channels = new ArrayList<>();

    public void addObserver(Channel channel) {
        this.channels.add(channel);
    }

    public void removeObserver(Channel channel) {
        this.channels.remove(channel);
    }

    public void setNews(String news) {
        this.news = news;
        for (Channel channel : this.channels) {
            channel.update(this.news);
        }
    }
}

public interface Channel {
    void update(String news);
}

public class NewsChannel implements Channel {
    @Override
    public void update(String news) {
        System.out.println("NewsChannel received news: " + news);
    }
}

Questo pattern è particolarmente utile per creare un sistema di comunicazione efficiente e ben organizzato tra componenti che necessitano di rimanere sincronizzati.

Quando Usare l’Observer

• Quando si Hanno Diverse Rappresentazioni dello Stesso Stato: Se hai molteplici forme di rappresentazione dello stesso stato e queste devono essere aggiornate simultaneamente, l’Observer è la scelta ideale.
• Quando il Cambiamento di Uno Stato Richiede Cambiamenti in Altri Oggetti: Se un oggetto deve essere in grado di notificare altri oggetti senza assumere nulla riguardo a chi siano questi oggetti, l’uso dell’Observer è appropriato.

• Quando l’Accoppiamento è da Evitare: L’Observer è utile per ridurre l’accoppiamento tra classi che altrimenti sarebbero strettamente legate. I soggetti non hanno bisogno di conoscere i dettagli dei loro osservatori.