PHP 5.3 позволяет создавать наследуемый одноэлементный класс с помощью поздней статической привязки:

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;
    }
}

это решает проблему, что до PHP 5.3 любой класс, который расширил Синглтон, будет создавать экземпляр своего родительского класса вместо своего собственного.

теперь вы можете сделать:

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

и $foo будет экземпляром Foobar вместо экземпляра Singleton.

к сожалению ответ Inwdr перерывы, когда есть несколько подклассов.

вот правильный наследуемый одноэлементный базовый класс.

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];
    }
}

тестовый код:

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

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

настоящий и современный способ сделать паттерн Singleton-это:

<?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() {}

}

теперь вы можете использовать ее как.

<?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

Как вы видите, эта реализация намного более гибкая.

вероятно, вам следует добавить частный метод _ _ clone (), чтобы запретить клонирование экземпляра.

private function __clone() {}

если вы не включаете этот метод, становится возможным следующее

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

теперь $inst1 != = $inst2 - они больше не являются одним и тем же экземпляром.

protected  static $_instance;

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

этот код может применяться для любого класса, не заботясь о его имени класса.

<?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(){
  }
}

использование:

/**
 *  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;

respose:

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

если вы используете PHP 5.4: признак его вариант, так что вам не придется тратить иерархию наследования, чтобы иметь Синглтон шаблон

а также обратите внимание, что ли вы используете черт или расширяет Синглтон класс один свободный конец должен был создать синглтон дочерних классов, если вы не добавляете следующую строку кода:

   protected static $inst = null;

в дочернем классе

неожиданный результат будет:

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

поддерживает несколько объектов с 1 строкой на класс:

этот метод будет применять синглтоны на любой класс, который вы хотите, все, что вам нужно сделать, это добавить 1 метод в класс, который вы хотите сделать Синглтон, и это сделает это за вас.

это также хранит объекты в классе "SingleTonBase", так что вы можете отлаживать все ваши объекты, которые вы использовали в вашей системе, рекурсивно SingleTonBase объекты.

---

создайте файл с именем SingletonBase.PHP и включить его в корень вашего скрипта!

код

abstract class SingletonBase
{
    private static $storage = array();

    public static function Singleton($class)
    {
        if(in_array($class,self::$storage))
        {
            return self::$storage[$class];
        }
        return self::$storage[$class] = new $class();
    }
    public static function storage()
    {
       return self::$storage;
    }
}

затем для любого класса вы хотите сделать синглтон просто добавить этот маленький один способ.

public static function Singleton()
{
    return SingletonBase::Singleton(get_class());
}

---

вот небольшой пример:

include 'libraries/SingletonBase.resource.php';

class Database
{
    //Add that singleton function.
    public static function Singleton()
    {
        return SingletonBase::Singleton(get_class());
    }

    public function run()
    {
        echo 'running...';
    }
}

$Database = Database::Singleton();

$Database->run();

и вы можете просто добавить эту одноэлементную функцию в любой класс, который у вас есть, и он будет создавать только 1 экземпляр на класс.

Примечание: вы всегда должны сделать _ _ construct private, чтобы исключить использование новых экземпляров Class ();.

class Database{

        //variable to hold db connection
        private $db;
        //note we used static variable,beacuse an instance cannot be used to refer this
        public static $instance;

        //note constructor is private so that classcannot be instantiated
        private function __construct(){
          //code connect to database  

         }     

         //to prevent loop hole in PHP so that the class cannot be cloned
        private function __clone() {}

        //used static function so that, this can be called from other classes
        public static function getInstance(){

            if( !(self::$instance instanceof self) ){
                self::$instance = new self();           
            }
             return self::$instance;
        }


        public function query($sql){
            //code to run the query
        }

    }


Access the method getInstance using
$db = Singleton::getInstance();
$db->query();

вся эта сложность ("позднего статического связывания" ... harumph) для меня просто признак сломанной модели объекта/класса PHP. Если бы объекты класса были объектами первого класса (см. Python), то "$_instance" был бы классом экземпляр переменная -- член объекта класса, в отличие от члена/свойства его экземпляров, а также в отличие от общих его потомков. В мире Smalltalk это разница между "переменной класса" и " экземпляром класса переменная."

в PHP мне кажется, что нам нужно принять близко к сердцу руководство о том, что шаблоны являются руководством по написанию кода-возможно, мы могли бы подумать о шаблоне Singleton, но попытка написать код, который наследуется от фактического класса "Singleton", выглядит ошибочной для PHP (хотя я предположил, что какая-то предприимчивая душа может создать подходящее ключевое слово SVN).

Я буду продолжать просто кодировать каждый синглтон отдельно, используя общий шаблон.

уведомления что я абсолютно остаюсь в стороне от обсуждения синглтонов-это зло, жизнь слишком коротка.

Я знаю, что это, вероятно, вызовет ненужную войну пламени, но я вижу, как вам может понадобиться более одного соединения с базой данных, поэтому я бы признал, что синглтон может быть не лучшим решением для этого... однако есть и другие варианты использования одноэлементного шаблона, которые я нахожу чрезвычайно полезными.

вот пример: я решил свернуть свой собственный MVC и шаблонный движок, потому что я хотел что-то действительно легкое. Однако данные, которые я хочу отобразить содержит много специальных математических символов, таких как ≥ и μ, и что у вас есть... Данные хранятся как фактический символ UTF-8 в моей базе данных, а не предварительно закодированный HTML, потому что мое приложение может поставлять другие форматы, такие как PDF и CSV в дополнение к HTML. Подходящее место для форматирования HTML находится внутри шаблона ("вид", если хотите), который отвечает за рендеринг этого раздела страницы (фрагмента). Я хочу преобразовать их в соответствующие HTML-объекты, но PHPs get_html_translation_table() функция не очень быстро. Имеет смысл извлекать данные один раз и хранить их в виде массива, делая их доступными для всех пользователей. Вот образец, который я собрал вместе, чтобы проверить скорость. Предположительно, это будет работать независимо от того, были ли другие методы, которые вы используете (после получения экземпляра), статическими или нет.

class EncodeHTMLEntities {

    private static $instance = null;//stores the instance of self
    private $r = null;//array of chars elligalbe for replacement

    private function __clone(){
    }//disable cloning, no reason to clone

    private function __construct()
    {
        $allEntities = get_html_translation_table(HTML_ENTITIES, ENT_NOQUOTES);
        $specialEntities = get_html_translation_table(HTML_SPECIALCHARS, ENT_NOQUOTES);
        $this->r = array_diff($allEntities, $specialEntities);
    }

    public static function replace($string)
    {
        if(!(self::$instance instanceof self) ){
            self::$instance = new self();
        }
        return strtr($string, self::$instance->r);
    }
}
//test one million encodings of a string
$start = microtime(true);
for($x=0; $x<1000000; $x++){
    $dump = EncodeHTMLEntities::replace("Reference method for diagnosis of CDAD, but clinical usefulness limited due to extended turnaround time (≥96 hrs)");
}
$end = microtime(true);
echo "Run time: ".($end-$start)." seconds using singleton\n";
//now repeat the same without using singleton
$start = microtime(true);
for($x=0; $x<1000000; $x++){
    $allEntities = get_html_translation_table(HTML_ENTITIES, ENT_NOQUOTES);
    $specialEntities = get_html_translation_table(HTML_SPECIALCHARS, ENT_NOQUOTES);
    $r = array_diff($allEntities, $specialEntities);
    $dump = strtr("Reference method for diagnosis of CDAD, but clinical usefulness limited due to extended turnaround time (≥96 hrs)", $r);
}
$end = microtime(true);
echo "Run time: ".($end-$start)." seconds without using singleton";

в основном, я видел типичные результаты, как это:

php test.php
Run time: 27.842966794968 seconds using singleton
Run time: 237.78191494942 seconds without using singleton

поэтому, хотя я, конечно, не эксперт, я не вижу более удобного и надежного способ уменьшить накладные расходы медленных вызовов для некоторых видов данных, делая его супер простым (одна строка кода, чтобы сделать то, что вам нужно). Конечно, в моем примере есть только один полезный метод, и поэтому он не лучше, чем глобально определенная функция, но как только у вас есть два метода, вы захотите сгруппировать их вместе, верно? Я?

кроме того, я предпочитаю примеры, которые на самом деле что-то делают, так как иногда трудно визуализировать, когда пример включает в себя операторы как "/ / сделать что-то полезное здесь", который я вижу все время при поиске учебников.

в любом случае, я хотел бы получить любую обратную связь или комментарии о том, почему использование синглтона для этого типа вещей вредно (или слишком сложно).

вы действительно не нужно использовать паттерн Singleton, потому что это антипаттерн. В принципе есть много причин, чтобы не реализовать эту схему. Прочитайте это для начала:Лучшая практика на PHP одноэлементных классов.

Если в конце концов вы все еще думаете, что вам нужно использовать шаблон Singleton, то мы могли бы написать класс, который позволит нам получить функциональность Singleton, расширив наш абстрактный класс SingletonClassVendor.

Это что я пришел, чтобы решить эту проблему.

<?php
namespace wl;


/**
 * @author DevWL
 * @dosc allows only one instance for each extending class.
 * it acts a litle bit as registry from the SingletonClassVendor abstract class point of view
 * but it provides a valid singleton behaviour for its children classes
 * Be aware, the singleton pattern is consider to be an anti-pattern
 * mostly because it can be hard to debug and it comes with some limitations.
 * In most cases you do not need to use singleton pattern
 * so take a longer moment to think about it before you use it.
 */
abstract class SingletonClassVendor
{
    /**
     *  holds an single instance of the child class
     *
     *  @var array of objects
     */
    protected static $instance = [];

    /**
     *  @desc provides a single slot to hold an instance interchanble between all child classes.
     *  @return object
     */
    public static final function getInstance(){
        $class = get_called_class(); // or get_class(new static());
        if(!isset(self::$instance[$class]) || !self::$instance[$class] instanceof $class){
            self::$instance[$class] = new static(); // create and instance of child class which extends Singleton super class
            echo "new ". $class . PHP_EOL; // remove this line after testing
            return  self::$instance[$class]; // remove this line after testing
        }
        echo "old ". $class . PHP_EOL; // remove this line after testing
        return static::$instance[$class];
    }

    /**
     * Make constructor abstract to force protected implementation of the __constructor() method, so that nobody can call directly "new Class()".
     */
    abstract protected 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() {}

}

пример использования:

/**
 * EXAMPLE
 */

/**
 *  @example 1 - Database class by extending SingletonClassVendor abstract class becomes fully functional singleton
 *  __constructor must be set to protected becaouse: 
 *   1 to allow instansiation from parent class 
 *   2 to prevent direct instanciation of object with "new" keword.
 *   3 to meet requierments of SingletonClassVendor abstract class
 */
class Database extends SingletonClassVendor
{
    public $type = "SomeClass";
    protected function __construct(){
        echo "DDDDDDDDD". PHP_EOL; // remove this line after testing
    }
}


/**
 *  @example 2 - Config ...
 */
class Config extends SingletonClassVendor
{
    public $name = "Config";
    protected function __construct(){
        echo "CCCCCCCCCC" . PHP_EOL; // remove this line after testing
    }
}

просто чтобы доказать, что он работает, как ожидалось:

/**
 *  TESTING
 */
$bd1 = Database::getInstance(); // new
$bd2 = Database::getInstance(); // old
$bd3 = Config::getInstance(); // new
$bd4 = Config::getInstance(); // old
$bd5 = Config::getInstance(); // old
$bd6 = Database::getInstance(); // old
$bd7 = Database::getInstance(); // old
$bd8 = Config::getInstance(); // old

echo PHP_EOL."COMPARE ALL DATABASE INSTANCES".PHP_EOL;
var_dump($bd1);
echo '$bd1 === $bd2' . ($bd1 === $bd2)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd2 === $bd6' . ($bd2 === $bd6)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd6 === $bd7' . ($bd6 === $bd7)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE

echo PHP_EOL;

echo PHP_EOL."COMPARE ALL CONFIG INSTANCES". PHP_EOL;
var_dump($bd3);
echo '$bd3 === $bd4' . ($bd3 === $bd4)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd4 === $bd5' . ($bd4 === $bd5)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE
echo '$bd5 === $bd8' . ($bd5 === $bd8)? ' TRUE' . PHP_EOL: ' FALSE' . PHP_EOL; // TRUE

эта статья охватывает тему довольно широко: http://www.phptherightway.com/pages/Design-Patterns.html#singleton

обратите внимание на следующее:

• конструктор __construct() объявлен protected чтобы предотвратить создание нового экземпляра вне класса через new оператора.
• волшебный способ __clone() объявлен private чтобы предотвратить клонирование экземпляра класса через clone оператор.
• волшебный способ __wakeup() объявлен private для предотвращения десериализация экземпляра класса через глобальную функцию unserialize().
• новый экземпляр создается с помощью позднего статического связывания в статический метод создания getInstance() ключевое слово static. Этот позволяет подкласс class Singleton в Примере.

Я давно написал назад думал поделиться здесь

class SingletonDesignPattern {

    //just for demo there will be only one instance
    private static $instanceCount =0;

    //create the private instance variable
    private static $myInstance=null;

    //make constructor private so no one create object using new Keyword
    private function  __construct(){}

    //no one clone the object
    private function  __clone(){}

    //avoid serialazation
    public function __wakeup(){}

    //ony one way to create  object
    public static  function  getInstance(){

        if(self::$myInstance==null){
            self::$myInstance=new SingletonDesignPattern();
            self::$instanceCount++;
        }
        return self::$myInstance;
    }

    public static function getInstanceCount(){
        return self::$instanceCount;
    }

}

//now lets play with singleton design pattern

$instance = SingletonDesignPattern::getInstance();
$instance = SingletonDesignPattern::getInstance();
$instance = SingletonDesignPattern::getInstance();
$instance = SingletonDesignPattern::getInstance();

echo "number of instances: ".SingletonDesignPattern::getInstanceCount();

Я согласен с первым ответом, но я бы также объявил класс окончательным, чтобы он не мог быть расширен, поскольку расширение синглтона нарушает шаблон синглтона. Кроме того, переменная экземпляра должна быть закрытой, чтобы к ней нельзя было получить прямой доступ. Также сделайте метод _ _ clone закрытым, чтобы вы не могли клонировать одноэлементный объект.

Ниже приведен пример кода.

/**
 * Singleton class
 *
 */
final class UserFactory
{
    private static $_instance = null;

    /**
     * Private constructor
     *
     */
    private function __construct() {}

    /**
     * Private clone method
     *
     */
     private function __clone() {}

    /**
     * Call this method to get singleton
     *
     * @return UserFactory
     */
    public static function getInstance()
    {
        if (self::$_instance === null) {
            self::$_instance = new UserFactory();
        }
        return self::$_instance;
    }
}

Пример Использования

$user_factory = UserFactory::getInstance();

что это мешает вам делать (что бы нарушить одноэлементный шаблон..

ВЫ НЕ МОЖЕТЕ ЭТОГО СДЕЛАТЬ!

$user_factory = UserFactory::$_instance;

class SecondUserFactory extends UserFactory { }

Это должен быть правильный путь Синглтона.

class Singleton {

    private static $instance;
    private $count = 0;

    protected function __construct(){

    }

    public static function singleton(){

        if (!isset(self::$instance)) {

            self::$instance = new Singleton;

        }

        return self::$instance;

    }

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

    protected function __clone(){

    }

    protected function __wakeup(){

    }

} 

Мне понравился метод @jose-segura использования признаков, но мне не понравилась необходимость определения статической переменной в подклассах. Ниже приведено решение, которое позволяет избежать этого путем кэширования экземпляров в статической локальной переменной в метод фабрики, индексированный по имени класса:

<?php
trait Singleton {

  # Single point of entry for creating a new instance. For a given
  # class always returns the same instance.
  public static function instance(){
    static $instances = array();
    $class = get_called_class();
    if( !isset($instances[$class]) ) $instances[$class] = new $class();
    return $instances[$class];
  }

  # Kill traditional methods of creating new instances
  protected function __clone() {}
  protected function __construct() {}
}

использование совпадает с @jose-segura только нет необходимости в статической переменной в подклассах.

класс базы данных, который проверяет, есть ли какой-либо существующий экземпляр базы данных, он вернет предыдущий экземпляр.

   class Database {  
        public static $instance;  
         public static function getInstance(){  
            if(!isset(Database::$instance) ) {  
                Database::$instance = new Database();  
            }  
           return Database::$instance;  
         }  
         private function __cunstruct() {  
           /* private and cant create multiple objects */  
         }  
         public function getQuery(){  
            return "Test Query Data";  
         }  
    }  
    $dbObj = Database::getInstance();  
    $dbObj2 = Database::getInstance();  
    var_dump($dbObj);  
    var_dump($dbObj2);  


/* 
After execution you will get following output: 

object(Database)[1] 
object(Database)[1] 

*/  

Ref http://www.phptechi.com/php-singleton-design-patterns-example.html

Это пример создания синглтона в классе базы данных

шаблоны проектирования 1) одноэлементные

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

     return Database::$instance;
    }

  }

  $db=Database::getInstance();
  $db2=Database::getInstance();
  $db3=Database::getInstance();

  var_dump($db);
  var_dump($db2);
  var_dump($db3);

затем положить это...

  object(Database)[1]
  object(Database)[1]
  object(Database)[1]

использовать только один экземпляр не создавать 3 экземпляра

вот мой пример, который обеспечивает возможность вызова как $var = new Singleton () а также создание 3 переменных для проверки, если он создает новый объект:

class Singleton{

    private static $data;

    function __construct(){
        if ($this::$data == null){
            $this->makeSingleton();
        }
        echo "<br/>".$this::$data;
    }

    private function makeSingleton(){
        $this::$data = rand(0, 100);
    }

    public function change($new_val){
        $this::$data = $new_val;
    }

    public function printme(){
        echo "<br/>".$this::$data;
    }

}


$a = new Singleton();
$b = new Singleton();
$c = new Singleton();

$a->change(-2);
$a->printme();
$b->printme();

$d = new Singleton();
$d->printme();