Il Pattern Factory Method

Pubblicato da

 


Il Pattern Factory Method è un design pattern creazionale che fornisce un'interfaccia per creare oggetti in una classe madre, ma permette alle sottoclassi di modificarne il tipo specifico di oggetto istanziato. Questo approccio consente di delegare la logica di creazione a una classe derivata, garantendo maggiore flessibilità e mantenibilità del codice.

🔗 Ti piace Techelopment? Dai un’occhiata al sito per tutti i dettagli!


Famiglia di Pattern: Pattern Creazionali

Il Factory Method appartiene alla famiglia dei design pattern creazionali, ovvero quei pattern che si occupano della creazione di oggetti in modo controllato e flessibile. A differenza della creazione diretta di istanze tramite il costruttore (new), il Factory Method permette di astrarre il processo di instanziazione e ridurre la dipendenza dalle classi concrete.


Diagramma





Come Funziona il Pattern Factory Method

Il Factory Method funziona definendo un metodo astratto in una classe base e delegando la creazione dell'oggetto alle sottoclassi concrete.

Esempio semplice

Immaginiamo di avere una gerarchia di oggetti Product e vogliamo creare diversi tipi di prodotti senza dipendere direttamente dalle loro classi concrete.

// Product interface
class Product {
    operation() {
        throw new Error("Method 'operation()' must be implemented.");
    }
}

// Concrete implementations
class ProductA extends Product {
    operation() {
        console.log("Operation of Product A");
    }
}

class ProductB extends Product {
    operation() {
        console.log("Operation of Product B");
    }
}

// Factory class
class Factory {
    static getFactory(type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            default:
                throw new Error("Unknown product type");
        }
    }
}

// Using the Factory Method
const product = Factory.getFactory("A");
product.operation();

In questo modo, possiamo istanziare un prodotto senza conoscere direttamente la sua classe concreta.


Un esempio più concreto

Immaginiamo di implementare un sistema per generare notifiche in un'applicazione, dove abbiamo diversi tipi di notifiche come Email, SMS e Instant Messaging.

// Notification interface
class Notification {
    send(message) {
        throw new Error("Method 'send()' must be implemented.");
    }
}

// Concrete implementations
class EmailNotification extends Notification {
    send(message) {
        console.log("Sending Email: " + message);
    }
}

class SMSNotification extends Notification {
    send(message) {
        console.log("Sending SMS: " + message);
    }
}

class IMNotification extends Notification {
    send(message) {
        console.log("Sending instant message: " + message);
    }
}

// Factory class
class NotificationFactory {
    static getFactory(preference) {
        switch (preference) {
            case "EMAIL":
                return new EmailNotification();
            case "SMS":
                return new SMSNotification();
            case "IM":
                return new IMNotification();
            default:
                throw new Error("Unknown notification type");
        }
    }
}

// Using the Factory Method
const user = //... get user info
const notification = NotificationFactory.getFactory(user.notification_preference);
notification.send("Hello, this is a test message!");

In questo modo, grazie al pattern Factory Method, abbiamo disaccoppiato l'invio del messaggio dalla tipologia di mezzo di comunicazione scelta dall'utente. Nel caso l'utente dovesse cambiare preferenza, il codice continuerà a funzionare senza necessità di aggiornamenti o revisioni.

Il Factory Method è un potente strumento per astrarre la creazione di oggetti e migliorare la manutenibilità del codice. Separando la logica di istanziazione dalle classi concrete, facilita l'estensibilità e riduce la dipendenza diretta dalle implementazioni specifiche. Questo pattern è particolarmente utile in scenari in cui il tipo di oggetto da creare varia in base al contesto o quando il processo di creazione è complesso.


Follow me #techelopment

Official site: www.techelopment.it
facebook: Techelopment
instagram: @techelopment
X: techelopment
Bluesky: @techelopment
telegram: @techelopment_channel
whatsapp: Techelopment
youtube: @techelopment