Modello di progettazione di fabbrica

Ciao amico! Oggi continueremo a studiare insieme a voi i design pattern. In questa lezione parleremo della Fabbrica. Discuteremo con te quale problema viene risolto utilizzando questo modello e vedremo un esempio di come una fabbrica aiuta ad aprire una caffetteria. E ti darò anche 5 semplici passaggi per creare una fabbrica. Per essere sulla stessa lunghezza d'onda con tutti e coglierne facilmente l'essenza, dovresti avere familiarità con i seguenti argomenti:

• Eredità in Java
• Restringimento ed espansione dei tipi di riferimento in Java
• Interazione tra classi e oggetti diversi

Cos'è una fabbrica?

Il modello di progettazione Factory consente di controllare la creazione degli oggetti. Il processo di creazione di un nuovo oggetto non è così semplice, ma non è nemmeno troppo complicato. Sappiamo tutti che per creare un nuovo oggetto dobbiamo utilizzare il file new. E può sembrare che qui non ci sia nulla da gestire, ma non è così. Possono sorgere difficoltà quando la nostra applicazione ha una certa classe che ha molti discendenti ed è necessario creare un'istanza di una certa classe in base ad alcune condizioni. Factory è un design pattern che aiuta a risolvere il problema della creazione di oggetti diversi a seconda di alcune condizioni. Astratto, no? Maggiore specificità e chiarezza appariranno guardando l'esempio seguente.

Creiamo diverse tipologie di caffè

Diciamo che vogliamo automatizzare una caffetteria. Dobbiamo imparare a preparare diversi tipi di caffè. Per fare ciò, nella nostra applicazione creeremo una classe di caffè e i suoi derivati: americano, cappuccino, espresso, latte - quei tipi di caffè che prepareremo. Cominciamo con la lezione generale sul caffè:

public class Coffee {
    public void grindCoffee(){
        // перемалываем кофе
    }
    public void makeCoffee(){
        // делаем кофе
    }
    public void pourIntoCup(){
        // наливаем в чашку
    }
}

Successivamente, creiamo i suoi eredi:

public class Americano extends Coffee {}
public class Cappuccino extends Coffee {}
public class CaffeLatte extends Coffee {}
public class Espresso extends Coffee {}

I nostri clienti ordineranno un tipo di caffè e queste informazioni devono essere trasmesse al programma. Questo può essere fatto in diversi modi, ad esempio utilizzando String. Ma è più adatto a questi scopi enum. Creiamo enume definiamo in esso i tipi di caffè per i quali accettiamo ordini:

public enum CoffeeType {
    ESPRESSO,
    AMERICANO,
    CAFFE_LATTE,
    CAPPUCCINO
}

Ottimo, ora scriviamo il codice per la nostra caffetteria:

public class CoffeeShop {

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucсino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }

        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Вот ваш кофе! Спасибо, приходите еще!");
        return coffee;
    }
}

Il metodo orderCoffeepuò essere suddiviso in due componenti:

1. Creazione di un'istanza di caffè specifica in un blocco switch-case. È qui che ciò che fa la Fabbrica è la creazione di un tipo specifico a seconda delle condizioni.
2. La preparazione stessa consiste nel macinare, cuocere e versare in una tazza.

Cosa è importante sapere se in futuro avrai bisogno di apportare modifiche al metodo:

1. L'algoritmo di preparazione stesso (macinatura, cottura e versamento in una tazza) rimarrà invariato (almeno lo speriamo).
2. Ma la gamma di caffè potrebbe cambiare. Forse inizieremo a fare la moka.. Mocha.. Mokkachi... Dio lo benedica, un nuovo tipo di caffè.

Possiamo già ipotizzare che in futuro, con un certo grado di probabilità, dovremo apportare modifiche al metodo, al blocco switch-case. È anche possibile che nella nostra caffetteria il metodo orderCoffeenon sia l'unico luogo in cui creiamo diversi tipi di caffè. Pertanto, le modifiche dovranno essere apportate in più punti. Probabilmente hai già capito a cosa voglio arrivare. Dobbiamo effettuare il refactoring. Sposta il blocco responsabile della creazione del caffè in una classe separata per due motivi:

1. Potremo riutilizzare la logica della creazione del caffè in altri luoghi.
2. Se la gamma cambia, non dovremo modificare il codice ovunque verrà utilizzata la creazione del caffè. Sarà sufficiente modificare il codice in un solo posto.

In altre parole, è ora di abbattere la fabbrica.

Stiamo segando la nostra prima fabbrica

Per fare ciò, creiamo una nuova classe che sarà responsabile solo della creazione delle istanze necessarie delle classi caffè:

public class SimpleCoffeeFactory {
    public Coffee createCoffee (CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }

        return coffee;
    }
}

Congratulazioni! Abbiamo appena implementato il modello di progettazione Factory nella sua forma più semplice. Anche se tutto potrebbe essere ancora più semplice se il metodo fosse reso createCoffeestatico. Ma allora perderemmo due possibilità:

1. Eredita da SimpleCoffeeFactoryed esegui l'override di createCoffee.
2. Implementa l'implementazione di fabbrica richiesta nelle nostre lezioni.

Parlando di implementazione. Dobbiamo tornare alla caffetteria e implementare la nostra fabbrica di caffè.

Introduzione di una fabbrica in una caffetteria

Riscriviamo la nostra lezione sulla caffetteria utilizzando una fabbrica:

public class CoffeeShop {

    private final SimpleCoffeeFactory coffeeFactory;

    public CoffeeShop(SimpleCoffeeFactory coffeeFactory) {
        this.coffeeFactory = coffeeFactory;
    }

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = coffeeFactory.createCoffee(type);
        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Вот ваш кофе! Спасибо, приходите еще!");
        return coffee;
    }
}

Grande. Proviamo ora a descrivere in modo schematico e conciso la struttura del design pattern Factory.

5 passi per aprire la tua fabbrica

Passaggio 1. Nel tuo programma hai una classe con diversi discendenti, come nell'immagine seguente: Passaggio 2. Crei una classe enumin cui definisci una variabile enum per ciascuna classe discendente:

enum CatType {
    LION,
    TIGER,
    BARSIK
}

Passaggio 3. Costruisci la tua fabbrica. Lo chiami MyClassFactory, il codice è qui sotto:

class CatFactory {}

Passaggio 4. Crei un metodo nella tua factory createMyClassche accetta la variabile - enum MyClassType. Codice qui sotto:

class CatFactory {
    public Cat createCat(CatType type) {

    }
}

Passaggio 5. Scrivi un blocco nel corpo del metodo switch-casein cui iteri tutti i valori enum e crei un'istanza della classe corrispondente al enumvalore:

class CatFactory {
        public Cat createCat(CatType type) {
            Cat cat = null;

            switch (type) {
                case LION:
                    cat =  new Barsik();
                    break;
                case TIGER:
                    cat = new Tiger();
                    break;
                case BARSIK:
                    cat =  new Lion();
                    break;
            }

            return cat;
        }
    }

Come un boss.

Come allenarsi

Leggere è bello, scrivere codice è ancora meglio. Se il tuo nome ha un numero pari di lettere, prova a creare la tua pizzeria virtuale. Se il tuo nome ha un numero dispari di lettere, prova a creare un sushi bar virtuale. Se sei anonimo, sei fortunato. Oggi puoi riposarti.