Erweiterung Singleton in PHP

Arbeite ich in einer web-app-framework, und ein Teil davon besteht aus einer Reihe von Dienstleistungen, die alle implementiert als Singleton. Sie alle erweitern die Service-Klasse, wo die singleton-Verhalten implementiert wird, suchen so etwas wie dieses:

class Service {
    protected static $instance;

    public function Service() {
        if (isset(self::$instance)) {
            throw new Exception('Please use Service::getInstance.');
        }
    }

    public static function &getInstance() {
        if (empty(self::$instance)) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

Nun, wenn ich eine Klasse namens FileService umgesetzt wie diese:

class FileService extends Service {
    //Lots of neat stuff in here
}

... der Aufruf der FileService::getInstance() wird nicht die Ausbeute eines FileService Beispiel, wie ich es mir vorstelle, aber ein Service-Instanz. Ich nehme an, das problem hier ist das "selbst" - Schlüsselwort in der Service-Konstruktor.

Gibt es eine andere Möglichkeit das zu erreichen, was ich hier will? Der singleton-code nur ein paar Zeilen, aber ich möchte trotzdem zu vermeiden, dass jede code-Redundanz, Wann immer ich kann.

InformationsquelleAutor Johan Fredrik Varen | 2010-06-27
  1. 55

    Code: 

    abstract class Singleton
{
    protected function __construct()
    {
    }

    final public static function getInstance()
    {
        static $instances = array();

        $calledClass = get_called_class();

        if (!isset($instances[$calledClass]))
        {
            $instances[$calledClass] = new $calledClass();
        }

        return $instances[$calledClass];
    }

    final private function __clone()
    {
    }
}

class FileService extends Singleton
{
    //Lots of neat stuff in here
}

$fs = FileService::getInstance();

    Wenn du PHP < 5.3, fügen Sie diese zu:

    //get_called_class() is only in PHP >= 5.3.
if (!function_exists('get_called_class'))
{
    function get_called_class()
    {
        $bt = debug_backtrace();
        $l = 0;
        do
        {
            $l++;
            $lines = file($bt[$l]['file']);
            $callerLine = $lines[$bt[$l]['line']-1];
            preg_match('/([a-zA-Z0-9\_]+)::'.$bt[$l]['function'].'/', $callerLine, $matches);
        } while ($matches[1] === 'parent' && $matches[1]);

        return $matches[1];
    }
}
    • FYI: Dieser code wird verwendet get_called_class, Hinzugefügt in PHP 5.3. Dies zu tun, in früheren Versionen ist einen Tick schwieriger.
    • Dank Charles, aktualisiert die Antwort, dass zu beheben.
    • Heilige Huch, das ist beängstigend. Imagine calling getInstance ein Dutzend mal, das ist ein Dutzend öffnet, und ein Dutzend liest der Klasse Datei.
    • Das ist, warum die Menschen sollten ein upgrade auf die neueste und beste ^^
    • Danke! Ich war eigentlich auf der Suche bei dieser Funktion gleich nachdem ich die Frage gepostet, aber ich war nicht sicher, wie Sie es verwenden, um das problem zu lösen. Nun, ich werde nur noch zu warten, bis der web-hotel-Jungs ein upgrade auf PHP5.3 🙂
    • vielleicht möchten Sie erwägen Notwasserung die Singletons verzichten. Sie stellen hard-Kupplung für Ihre Anwendung und sind schwer zu testen. Können Sie lösen die dürfen-müssen-nur-ein-Beispiel-Problem mit einem Dependency Injection-Framework oder eine Registrierung.
    • Bedeutet die Erweiterung der Klasse' Konstruktor werden der öffentlichkeit dann?
    • Ich habe ein eigenes getCalledClass () - Methode in der Singleton-Klasse, in der ich prüfe, ob die Funktion get_called_class vorhanden ist (möchte ich alle Codes zusammen zu sein). Was mache ich falsch? Es scheint zu funktionieren 🙂

    InformationsquelleAutor Amy B
  2. 8

    Hatte ich mehr Aufmerksamkeit in 5.3 Klasse, ich hätte gewusst, wie man dieses Problem lösen mich. Mit der neuen late-static-binding-Funktion von PHP 5.3, ich glaube, Coronatus' proposition kann vereinfacht werden, in diesem:

    class Singleton {
    protected static $instance;

    protected function __construct() { }

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

        return static::$instance;
    }

    final private function __clone() { }
}

    Ich es ausprobiert, und es funktioniert wie ein Charme. Pre 5.3 ist noch eine ganz andere Geschichte, aber.

    • Es scheint, gibt es nur ein einziges Feld $instance für alle Unterklassen, also nur die singleton-Instanz der Klasse, wo getInstance() ersten mal aufgerufen wird, wird zurückgegeben.
    • Dies ist der naive Ansatz, der leider überhaupt nicht funktionieren kann als C-Otto bereits erwähnt. Downvoted: tun Sie das nicht zu Hause 😉
    • Als Sie oben gesagt.. es ist falsch, diese geben Sie die Instanz der ersten Klasse, die verwendet getInstance()
    • Yup, tun das nicht.
    InformationsquelleAutor Johan Fredrik Varen
  3. 3

    Dieser behoben wird, Johan Antwort. PHP 5.3+

    abstract class Singleton
{
    protected function __construct() {}
    final protected function __clone() {}

    final public static function getInstance()
    {
        static $instance = null;

        if (null === $instance)
        {
            $instance = new static();
        }

        return $instance;
    }
}
    InformationsquelleAutor Alexey Filatov
  4. 1

    Habe ich eine gute Lösung gefunden.

    Folgendes ist mein code

    abstract class Singleton
{
    protected static $instance; //must be protected static property ,since we must use static::$instance, private property will be error

    private function __construct(){} //must be private !!! [very important],otherwise we can create new father instance in it's Child class 

    final protected function __clone(){} #restrict clone

    public static function getInstance()
    {
        #must use static::$instance ,can not use self::$instance,self::$instance will always be Father's static property 
        if (! static::$instance instanceof static) {
            static::$instance = new static();
        }
        return static::$instance;
    }
}

class A extends Singleton
{
   protected static $instance; #must redefined property
}

class B extends A
{
    protected static $instance;
}

$a = A::getInstance();
$b = B::getInstance();
$c = B::getInstance();
$d = A::getInstance();
$e = A::getInstance();
echo "-------";

var_dump($a,$b,$c,$d,$e);

#object(A)#1 (0) { }
#object(B)#2 (0) { } 
#object(B)#2 (0) { } 
#object(A)#1 (0) { } 
#object(A)#1 (0) { }

    Finden Sie http://php.net/manual/en/language.oop5.late-static-bindings.php
    für mehr info

    • ab welcher version wird das unterstützt?
    InformationsquelleAutor Martin Ding
Schreibe einen Kommentar