PHP – Design Pattern Singleton

I design pattern sono degli schemi che mostrano una soluzione progettuale flessibile per problemi di programmazione comuni.
Ogni pattern descrive un problema ricorrente indicando la soluzione per risolverlo nel modo migliore possibile.
Non si tratta di componenti software veri e propri (come per esempio una libreria) ma piuttosto, come dice Wikipedia di:

…una descrizione o un modello da applicare per risolvere un problema che può presentarsi in diverse situazioni durante la progettazione e lo sviluppo del software.

Vista la loro natura, i pattern non sono le legati ad uno specifico linguaggio di programmazione, anzi ne sono totalmente indipendenti, l’unico requisito necessario è che il linguaggio supporti la programmazione ad oggetti. PHP dalla versione 5 lo fa in maniera più che dignitosa.

Il Pattern Singleton

Questo pattern, dall’implementazione piuttosto semplice, è utilizzato per limitare ad una sola le istanze di un oggetto, prevedendo un punto di accesso globale ad essa.

Implementazione

Per implementare questo pattern la prima cosa da fare è rendere privato il costruttore per impedire che possa essere creata una nuova istanza bloccando quindi l’istanziazione diretta della classe. Poi si dovrà creare una proprietà statica privata che conterrà l’unica istanza della classe consentita. Quindi un metodo statico privato che restituisca l’istanza contenuta nella proprietà precedente, o che la crei salvandone il riferimento nella proprietà statica in caso l’istanza ancora non esista.
Il diagramma UML del pattern è il seguente:

Esempio

Vediamo ora un esempio di implementazione del pattern singleton in PHP:

<?php
/**
 * Singleton Pattern
 *
 * @author Simone
 */
class Singleton {
    private static $_instance;
    private $count = 0;

    private function __construct() {}

    public static function getInstance() {
        if (!isset(self::$_instance)) {
            $class = __CLASS__;
            self::$_instance = new $class;
        }

        return self::$_instance;
    }

    public function increment() {
        return $this->count++;
    }

    public function __clone() {
        trigger_error('La clonazione non è consentita', E_USER_ERROR);
    }

}

$obj1 = Singleton::getInstance();
echo $obj1->increment() . PHP_EOL; //0

$obj2 = Singleton::getInstance();
echo $obj2->increment() . PHP_EOL; //1

$obj3 = clone $obj1;
?>

Possiamo notare:

1. Come il costruttore sia stato dichiarato privato.
2. Come il getter dell’istanza getInstance() (metodo statico) si limiti a restituire l’unica istanza della classe memorizzata nella proprietà statica $_instance.
3. Che il metodo magico __clone generi un errore nel caso venga chiamato. Questa è solo una variante al rendere privato il metodo, proprio come il costruttore difatti si vuole evitare che siano generate nuove istanze della classe.

Il risultato del metodo increment() serve proprio a dimostrare che sia $obj1 che $obj2 contengono un riferimento alla stessa istanza.

Singleton deprecato

Negli ultimi anni sono state mosse numerose critiche a questo pattern al punto da farlo considerare una “bad practice”. Tra i principali appunti troviamo:

1. Nasconde le dipendenze dell’applicazione nel codice, invece di esporle attraverso le interfacce.
2. Viola il Single Responsibility Principle.
3. Rende problematico il testing ed il debug del codice.