PHP -Design Pattern Factory Method

Nella programmazione OOP quando si parla di pattern ci si riferisce semplicemente alle pratiche migliori per risolvere un determinato e noto problema. Ciò significa che anche se è possibile risolvere il problema con metodi alternativi, un pattern sarà il modo più efficace per raggiungere l’obiettivo.

Il pattern factory method (detto anche come Virtual Constructor) è probabilmente uno dei più utilizzati e conosciuti. Nella vita reale, una fabbrica crea oggetti.  Allo stesso modo, in un pattern factory, consiste nella ‘fabbrica’ con la quale si creano oggetti.
[box type=”note”]In generale si parla di fabbriche quando si vuole confinare da qualche parte i dettagli della creazione di oggetti.[/box]

Quando è utile

L’implementazione di questo pattern risulta particolarmente indicata quando abbiamo un set di classi ma non sappiamo fino a runtime quale dobbiamo concretamente istanziare. E’ chiamato factory proprio perché crea vari tipi di oggetti  senza necessariamente sapere che tipo di oggetto sta creando o come lo sta facendo.

Struttura

Le classi (e/o interfacce) che partecipano alla creazione di questo pattern sono le seguenti:

• Prodotto: è l’interfaccia implementata da tutti gli oggetti creati dal CreatoreConcreto (che vedremo dopo). Spesso è rappresentato anche con una classe astratta.
• ProdottoConcreto: implementa l’intefaccia definita da Prodotto. Il ProdottoConcreto sarà generato dal CreatoreConcreto.
• Creatore:  è l’interfaccia implementata dal CratoreConcreto. Definisce un metodo (metodo factory) che si occupa di creare un ProdottoConcreto. Molte volte questa interfaccia è definita come classe astratta con un metodo factory che restituisce un prodotto di default.
• CreatoreConcreto: implementa l’override del metodo factory del Cratore per restituire ProdottiConcreti specifici.

Implementazione

Di solito al fine di evitare la proliferazione di classi, in PHP si opta per non utilizzare il Creatore ma implementare direttamente  il CreatoreConcreto dando un comportamento parametrizzato al metodo factory che restituirà l’istanza di uno dei ProdottiConcreti definiti in base ad un parametro passatogli.

Esempio

Supponiamo di avere una fabbrica che genera qualsiasi tipo di macchina. Quando creiamo una nuova macchina non abbiamo bisogno di sapere come è fatta o quanto è diversa da un’altra.
Il pattern incapsula come le cose sono fatte, quindi noi non abbiamo bisogno di conoscerne i dettagli. Se un tipo di macchina cambia il modo con cui è fatta, non ce ne dobbiamo preoccupare.
La classe della macchina cambierà ma come si accede a quella classe rimane invariato.

<?php
//Creatore Conreto.
class CarFactory {   
    //Matodo factory, che si occupa di creare gli oggetti.
    public static function createCar($carType){
        if (class_exists($carType)) {
            return new $carType;
        } else {
            die("Tipo di macchina sconosciuto");
        }
    }   
}

//Prodotto. Classe astratta da cui deriveranno tutti Prodotti Concreti.
abstract class Car {
    public function getType(){
        echo $this->_type . PHP_EOL;
    }
}

//Classe che contiene tutti i dettagli su come fare una Ferrari.
class Ferrari extends Car{
    protected $_type = "Ferrari";

    //Altro codice che rende questa vettura diversa dalle altre.
}

//Classe che contiene tutti i dettagli su come fare una Lamborghini.
class Lamborghini extends Car{
    protected $_type = "Lamborghini";

    //Altro codice che rende questa vettura diversa dalle altre.
}

//Classe che contiene tutti i dettagli su come fare una Bianchina.
class Bianchina extends Car{
    protected $_type = "Bianchina";

    // overidde del metodo
    public function getType(){
        echo $this->_type . ' ma esiste ancora?';
    }
    //Altro codice che rende questa vettura diversa dalle altre.
}

//Creo "fabbrica di macchine"
$carFactory = new CarFactory();

//Creo una macchina
$Ferrari = $carFactory->createCar('Ferrari');
//Ottengo il tipo.
$Ferrari->getType();

$Lamborghini = $carFactory->createCar('Lamborghini');
$Lamborghini->getType();

$Bianchina = $carFactory->createCar('Bianchina');
$Bianchina->getType();
?>

Il metodo factory createCar() è la chiave di tutto, questi si occupa di creare le macchine (istanziare le classi) in base al parametro passatogli. Se il parametro non corrisponde a nessuna classe allora sarà generato un messaggio di errore.
Ognuno degli oggetti creati dal factory method (ConcreteProduct) è di classe differente. La soluzione per poter ignorare questo aspetto è che tutti implementino la stessa classe astratta (Product).
[note]Il metodo factory dovrebbe essere statico così da consentire di istanziare classi velocemente.[/note]

Come possiamo notare siamo in grado di creare ed utilizzare i prodotti creati dal factory senza doverci preoccupare della loro implementazione specifica. In questo modo qualsiasi modifica apportata direttamente sul ProdottoConcreto non genererà nessun problema all’interno dell’applicazione.