Erstellen des Singleton-Entwurfsmusters in PHP5

Wie würde man eine Singleton-Klasse mit PHP5-Klassen erstellen?

/**
 * Singleton class
 *
 */
final class UserFactory
{
    /**
     * Call this method to get singleton
     *
     * @return UserFactory
     */
    public static function Instance()
    {
        static $inst = null;
        if ($inst === null) {
            $inst = new UserFactory();
        }
        return $inst;
    }

    /**
     * Private ctor so nobody else can instantiate it
     *
     */
    private function __construct()
    {

    }
}

Benutzen:

$fact = UserFactory::Instance();
$fact2 = UserFactory::Instance();

$fact == $fact2;

Aber:

$fact = new UserFactory()

Wirft einen Fehler.

Sehen http://php.net/manual/en/language.variables.scope.php#language.variables.scope.static um den Gültigkeitsbereich statischer Variablen und die Gründe für die Einstellung zu verstehen static $inst = null; funktioniert.

Leider bricht die Antwort von Inwdr, wenn es mehrere Unterklassen gibt.

Hier ist eine korrekte vererbbare Singleton-Basisklasse.

class Singleton
{
    private static $instances = array();
    protected function __construct() {}
    protected function __clone() {}
    public function __wakeup()
    {
        throw new Exception("Cannot unserialize singleton");
    }

    public static function getInstance()
    {
        $cls = get_called_class(); // late-static-bound class name
        if (!isset(self::$instances[$cls])) {
            self::$instances[$cls] = new static;
        }
        return self::$instances[$cls];
    }
}

Testcode:

class Foo extends Singleton {}
class Bar extends Singleton {}

echo get_class(Foo::getInstance()) . "\n";
echo get_class(Bar::getInstance()) . "\n";

PHP 5.3 ermöglicht die Erstellung einer vererbbaren Singleton-Klasse über spätes statisches Binden:

class Singleton
{
    protected static $instance = null;

    protected function __construct()
    {
        //Thou shalt not construct that which is unconstructable!
    }

    protected function __clone()
    {
        //Me not like clones! Me smash clones!
    }

    public static function getInstance()
    {
        if (!isset(static::$instance)) {
            static::$instance = new static;
        }
        return static::$instance;
    }
}

Dies löst das Problem, dass vor PHP 5.3 jede Klasse, die ein Singleton erweitert hat, statt ihrer eigenen eine Instanz ihrer übergeordneten Klasse erzeugt hat.

Jetzt können Sie Folgendes tun:

class Foobar extends Singleton {};
$foo = Foobar::getInstance();

Und $foo wird eine Instanz von Foobar statt einer Instanz von Singleton sein.

Das Echte und Moderne Möglichkeit, Singleton-Muster zu erstellen, ist:

<?php

/**
 * Singleton Pattern.
 * 
 * Modern implementation.
 */
class Singleton
{
    /**
     * Call this method to get singleton
     */
    public static function instance()
    {
      static $instance = false;
      if( $instance === false )
      {
        // Late static binding (PHP 5.3+)
        $instance = new static();
      }

      return $instance;
    }

    /**
     * Make constructor private, so nobody can call "new Class".
     */
    private function __construct() {}

    /**
     * Make clone magic method private, so nobody can clone instance.
     */
    private function __clone() {}

    /**
     * Make sleep magic method private, so nobody can serialize instance.
     */
    private function __sleep() {}

    /**
     * Make wakeup magic method private, so nobody can unserialize instance.
     */
    private function __wakeup() {}

}

So, jetzt können Sie es gerne verwenden.

<?php

/**
 * Database.
 *
 * Inherited from Singleton, so it's now got singleton behavior.
 */
class Database extends Singleton {

  protected $label;

  /**
   * Example of that singleton is working correctly.
   */
  public function setLabel($label)
  {
    $this->label = $label;
  }

  public function getLabel()
  {
    return $this->label;
  }

}

// create first instance
$database = Database::instance();
$database->setLabel('Abraham');
echo $database->getLabel() . PHP_EOL;

// now try to create other instance as well
$other_db = Database::instance();
echo $other_db->getLabel() . PHP_EOL; // Abraham

$other_db->setLabel('Priler');
echo $database->getLabel() . PHP_EOL; // Priler
echo $other_db->getLabel() . PHP_EOL; // Priler

Wie Sie sehen, ist diese Realisierung viel flexibler.

Sie sollten wahrscheinlich eine private __clone()-Methode hinzufügen, um das Klonen einer Instanz zu verbieten.

private function __clone() {}

Wenn Sie diese Methode nicht einschließen, wird Folgendes möglich

$inst1=UserFactory::Instance(); // to stick with the example provided above
$inst2=clone $inst1;

jetzt $inst1 !== $inst2 – sie sind nicht mehr dieselbe Instanz.

<?php
/**
 * Singleton patter in php
 **/
trait SingletonTrait {
   protected static $inst = null;

  /**
   * call this method to get instance
   **/
   public static function getInstance(){
      if (static::$inst === null){
         static::$inst = new static();
      }
      return static::$inst;
  }

  /**
   * protected to prevent clonning 
   **/
  protected function __clone(){
  }

  /**
   * protected so no one else can instance it 
   **/
  protected function __construct(){
  }
}

benutzen:

/**
 *  example of class definitions using SingletonTrait
 */
class DBFactory {
  /**
   * we are adding the trait here 
   **/
   use SingletonTrait;

  /**
   * This class will have a single db connection as an example
   **/
  protected $db;


 /**
  * as an example we will create a PDO connection
  **/
  protected function __construct(){
    $this->db = 
        new PDO('mysql:dbname=foodb;port=3305;host=127.0.0.1','foouser','foopass');
  }
}
class DBFactoryChild extends DBFactory {
  /**
   * we repeating the inst so that it will differentiate it
   * from UserFactory singleton
   **/
   protected static $inst = null;
}


/**
 * example of instanciating the classes
 */
$uf0 = DBFactoryChild::getInstance();
var_dump($uf0);
$uf1 = DBFactory::getInstance();
var_dump($uf1);
echo $uf0 === $uf1;

Antwort:

object(DBFactoryChild)#1 (0) {
}
object(DBFactory)#2 (0) {
}

Wenn Sie PHP 5.4 verwenden: Merkmal Es ist eine Option, sodass Sie die Vererbungshierarchie nicht verschwenden müssen, um die zu haben Singleton-Muster

und beachten Sie auch, ob Sie verwenden Züge oder erweitert Singleton Das lose Ende von Klasse 1 bestand darin, Singleton von untergeordneten Klassen zu erstellen, wenn Sie die folgende Codezeile nicht hinzufügen:

   protected static $inst = null;

in der Kinderklasse

das unerwartete Ergebnis wird sein:

object(DBFactoryChild)#1 (0) {
}
object(DBFactoryChild)#1 (0) {
}

protected  static $_instance;

public static function getInstance()
{
    if(is_null(self::$_instance))
    {
        self::$_instance = new self();
    }
    return self::$_instance;
}

Dieser Code kann für jede Klasse gelten, ohne sich um den Klassennamen zu kümmern.