Создание шаблона проектирования Singleton в PHP5
https://stackoverflow.com/questions/203336
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Как бы создать одноэлементный класс, используя классы PHP5?
Решение
/**
* 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()
{
}
}
Для использования:
$fact = UserFactory::Instance();
$fact2 = UserFactory::Instance();
$fact == $fact2;
Но:
$fact = new UserFactory()
Выдает ошибку.
Видишь http://php.net/manual/en/language.variables.scope.php#language.variables.scope.static чтобы понять области действия статических переменных и зачем устанавливать static $inst = null; работает.
Другие советы
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 любой класс, который расширял Singleton, создавал экземпляр своего родительского класса вместо своего собственного.
Теперь вы можете сделать:
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";
Настоящий и Современный способ создания одноэлементного шаблона - это:
<?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 - это уже не один и тот же экземпляр.
<?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;
передохнуть:
object(DBFactoryChild)#1 (0) {
}
object(DBFactory)#2 (0) {
}
Если вы используете PHP 5.4: черта характера это вариант, так что вам не нужно тратить впустую иерархию наследования, чтобы иметь Одноэлементный паттерн
а также обратите внимание, используете ли вы Трейты или расширяет Синглтон класс одним из недостатков было создание синглтона дочерних классов, если вы не добавите следующую строку кода:
protected static $inst = null;
в дочернем классе
неожиданным результатом будет:
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;
}
Этот код может применяться к любому классу, не заботясь о его имени.
Поддерживает несколько объектов по 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 закрытым, чтобы исключить использование new 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();
На самом деле вам не нужно использовать одноэлементный шаблон, потому что он считается антипаттером.В принципе, есть много причин для того, чтобы вообще не внедрять этот шаблон.Прочтите это для начала: Лучшая практика работы с одноэлементными классами 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
Вся эта сложность ("поздняя статическая привязка" ...harumph) для меня - это просто признак неработающей модели объекта / класса PHP.Если бы объекты класса были объектами первого класса (см. Python), то "$_instance" был бы классом экземпляр переменная - член класса object, в отличие от члена/ свойства его экземпляров, а также в отличие от разделяемого его потомками.В мире Smalltalk это разница между "переменной класса" и "переменной экземпляра класса".
В PHP мне кажется, что нам нужно принять близко к сердцу руководство о том, что шаблоны являются руководством к написанию кода - возможно, мы могли бы подумать об одноэлементном шаблоне, но попытка написать код, который наследуется от реального "одноэлементного" класса, выглядит ошибочной для PHP (хотя я предположил, что какая-нибудь предприимчивая душа могла бы создать подходящее ключевое слово SVN).
Я продолжу просто кодировать каждый синглтон отдельно, используя общий шаблон.
Обратите внимание, что я абсолютно не вмешиваюсь в дискуссию о том, что одиночки - это зло, жизнь слишком коротка.
Я знаю, что это, вероятно, вызовет ненужную флейм-войну, но я вижу, что вам может потребоваться более одного подключения к базе данных, поэтому я бы согласился с тем, что singleton может быть не лучшим решением для этого...однако существуют и другие варианты использования шаблона singleton, которые я нахожу чрезвычайно полезными.
Вот пример:Я решил создать свой собственный MVC и движок для создания шаблонов, потому что мне хотелось чего-то действительно легкого.Однако данные, которые я хочу отобразить, содержат много специальных математических символов, таких как ≥ и μ, и что у вас есть...Данные хранятся в моей базе данных в виде фактического символа UTF-8, а не в предварительном HTML-кодировании, потому что мое приложение может предоставлять другие форматы, такие как PDF и CSV, в дополнение к HTML.Подходящее место для форматирования HTML находится внутри шаблона ("просмотр", если хотите), который отвечает за отображение этого раздела страницы (сниппета).Я хочу преобразовать их в соответствующие HTML-объекты, но функция get_html_translation_table() PHPs работает не очень быстро.Имеет смысл извлечь данные один раз и сохранить в виде массива, сделав их доступными для всех.Вот образец, который я собрал, чтобы проверить скорость.Предположительно, это сработало бы независимо от того, были ли другие методы, которые вы используете (после получения экземпляра), статическими или нет.
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
Поэтому, хотя я, конечно, не эксперт, я не вижу более удобного и надежного способа уменьшить накладные расходы на медленные вызовы какого-либо вида данных, сделав это при этом супер простым (одна строка кода для выполнения того, что вам нужно).Конечно, в моем примере есть только один полезный метод, и поэтому он ничем не лучше глобально определенной функции, но как только у вас будет два метода, вы захотите сгруппировать их вместе, не так ли?Я сильно отклонился от темы?
Кроме того, я предпочитаю примеры, которые действительно что-то делают, поскольку иногда трудно визуализировать, когда пример включает в себя утверждения типа "// сделай что-нибудь полезное здесь", которые я постоянно вижу при поиске руководств.
В любом случае, я был бы рад любым отзывам или комментариям о том, почему использование синглтона для такого рода задач вредно (или чрезмерно сложно).
Эта статья довольно широко охватывает тему: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();
Я согласен с первым ответом, но я бы также объявил класс как окончательный, чтобы его нельзя было расширить, поскольку расширение синглтона нарушает шаблон singleton.Кроме того, переменная экземпляра должна быть закрытой, чтобы к ней нельзя было получить прямой доступ.Также сделайте метод __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();
Что это останавливает вас от выполнения (что нарушило бы шаблон singleton..
ТЫ НЕ МОЖЕШЬ ЭТОГО СДЕЛАТЬ!
$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]
*/
Ссылка 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);
тогда out put - это --
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();
