Creazione del modello di progettazione Singleton in PHP5
https://stackoverflow.com/questions/203336
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Come si crea una classe Singleton usando le classi PHP5?
Soluzione
/**
* 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()
{
}
}
Per usare:
$fact = UserFactory::Instance();
$fact2 = UserFactory::Instance();
$ fact == $ fact2;
Ma:
$fact = new UserFactory()
Genera un errore.
Vedi http://php.net/manual/en/language.variables.scope.php#language.variables.scope.static per comprendere gli ambiti delle variabili statiche e perché impostare static $ inst = null; funziona.
Altri suggerimenti
PHP 5.3 consente la creazione di una classe Singleton ereditabile tramite associazione statica tardiva:
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;
}
}
Questo risolve il problema, che prima di PHP 5.3 qualsiasi classe che estendesse un Singleton avrebbe prodotto un'istanza della sua classe genitrice invece della sua.
Ora puoi fare:
class Foobar extends Singleton {};
$foo = Foobar::getInstance();
E $ foo sarà un'istanza di Foobar anziché un'istanza di Singleton.
Purtroppo Risposta di Inwdr si interrompe quando ci sono più sottoclassi.
Ecco una classe base Singleton ereditabile corretta.
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];
}
}
Codice test:
class Foo extends Singleton {}
class Bar extends Singleton {}
echo get_class(Foo::getInstance()) . "\n";
echo get_class(Bar::getInstance()) . "\n";
Il vero e moderno per creare il modello 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() {}
}
Quindi ora puoi usarlo come.
<?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
Come vedi questa realizzazione è molto più flessibile.
Probabilmente dovresti aggiungere un metodo __clone () privato per impedire la clonazione di un'istanza.
private function __clone() {}
Se non includi questo metodo, diventa possibile
$inst1=UserFactory::Instance(); // to stick with the example provided above
$inst2=clone $inst1;
ora $ inst1 ! == $ inst2 - non sono più la stessa istanza.
<?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(){
}
}
da usare:
/**
* 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) {
}
Se stai usando PHP 5.4: trait è un'opzione, quindi non devi sprecare la gerarchia ereditaria per avere Modello Singleton
e nota anche che se usi trait o estende la classe Singleton un'estremità libera era quella di creare singleton di classi secondarie se non si aggiungeva la seguente riga di codice:
protected static $inst = null;
nella classe figlio
il risultato imprevisto sarà:
object(DBFactoryChild)#1 (0) {
}
object(DBFactoryChild)#1 (0) {
}
protected static <*>
Questo codice può essere applicato a qualsiasi classe senza preoccuparsi del nome della sua classe.
instance;
public static function getInstance()
{
if(is_null(self::<*>
Questo codice può essere applicato a qualsiasi classe senza preoccuparsi del nome della sua classe.
instance))
{
self::<*>
Questo codice può essere applicato a qualsiasi classe senza preoccuparsi del nome della sua classe.
instance = new self();
}
return self::<*>
Questo codice può essere applicato a qualsiasi classe senza preoccuparsi del nome della sua classe.
instance;
}
Questo codice può essere applicato a qualsiasi classe senza preoccuparsi del nome della sua classe.
Supporta più oggetti con 1 riga per classe:
Questo metodo imporrà i singleton su qualsiasi classe tu voglia, al momento devi solo aggiungere 1 metodo alla classe che desideri creare un singleton e questo lo farà per te.
Questo memorizza anche gli oggetti in un "SingleTonBase" in modo da poter eseguire il debug di tutti gli oggetti utilizzati nel sistema ricorrendo agli oggetti SingleTonBase .
Crea un file chiamato SingletonBase.php e includilo nella radice del tuo script!
Il codice è
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;
}
}
Quindi per ogni classe che vuoi creare un singleton aggiungi questo piccolo metodo singolo.
public static function Singleton()
{
return SingletonBase::Singleton(get_class());
}
Ecco un piccolo esempio:
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();
E puoi semplicemente aggiungere questa funzione singleton in qualsiasi classe tu abbia e creerà solo 1 istanza per classe.
NOTA: dovresti sempre rendere privato __construct per eliminare l'uso di new Class (); istanze.
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();
Non hai davvero bisogno di usare il modello Singleton perché è considerato un antipattern. Fondamentalmente ci sono molte ragioni per non implementare affatto questo modello. Leggi questo per iniziare con: Best practice sulle classi singleton PHP .
Se dopo tutto pensi ancora di dover usare il modello Singleton, allora potremmo scrivere una classe che ci permetterà di ottenere la funzionalità Singleton estendendo la nostra classe astratta SingletonClassVendor.
Questo è quello che mi è venuto in mente per risolvere questo problema.
<?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() {}
}
Esempio d'uso:
/**
* 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
}
}
Solo per dimostrare che funziona come previsto:
/**
* 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
Tutta questa complessità ("associazione statica tardiva" ... harumph) è, per me, semplicemente un segno del modello di classe / oggetto rotto di PHP. Se gli oggetti di classe erano oggetti di prima classe (vedi Python), allora " $ _ istanza " sarebbe una variabile istanza di classe - un membro dell'oggetto class, al contrario di un membro / proprietà delle sue istanze, e anche al contrario di condiviso dai suoi discendenti. Nel mondo Smalltalk, questa è la differenza tra una "variabile di classe" e una "variabile di istanza di classe".
In PHP, mi sembra che dobbiamo prendere a cuore la guida secondo cui i pattern sono una guida per scrivere codice - potremmo forse pensare a un modello Singleton, ma provando a scrivere codice che eredita da un reale " ; Singleton " la classe sembra sbagliata per PHP (anche se suppongo che un'anima intraprendente possa creare una parola chiave SVN adatta).
Continuerò a codificare ogni singolo singleton separatamente, usando un modello condiviso.
Nota che sto assolutamente FUORI dalla discussione sui singletons-are-evil, la vita è troppo breve.
So che questo probabilmente causerà una guerra di fiamma non necessaria, ma posso vedere come potresti desiderare più di una connessione al database, quindi concederei che singleton potrebbe non essere la soluzione migliore per quello ... comunque , ci sono altri usi del modello singleton che trovo estremamente utili.
Ecco un esempio: ho deciso di girare il mio MVC e il mio motore di template perché volevo qualcosa di veramente leggero. Tuttavia, i dati che voglio visualizzare contengono molti caratteri matematici speciali come = e µ e cosa hai ... I dati vengono archiviati come effettivi caratteri UTF-8 nel mio database anziché codificati in pre-HTML perché la mia app può fornire altri formati come PDF e CSV oltre all'HTML. Il luogo appropriato per la formattazione dell'HTML è all'interno del modello (" visualizza " se vuoi) che è responsabile del rendering di quella sezione di pagina (snippet). Voglio convertirli nelle loro entità HTML appropriate, ma la funzione get_html_translation_table () dei PHP non è super veloce. Ha più senso recuperare i dati una volta e archiviarli come array, rendendoli disponibili per tutti. Ecco un esempio che ho messo insieme per testare la velocità. Presumibilmente, questo funzionerebbe indipendentemente dal fatto che gli altri metodi che usi (dopo aver ottenuto l'istanza) fossero statici o meno.
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";
Fondamentalmente, ho visto risultati tipici come questo:
php test.php Run time: 27.842966794968 seconds using singleton Run time: 237.78191494942 seconds without using singleton
Quindi, anche se non sono certamente un esperto, non vedo un modo più conveniente e affidabile per ridurre il sovraccarico delle chiamate lente per alcuni tipi di dati, rendendolo al contempo semplicissimo (singola riga di codice per fare ciò che bisogno). Concesso il mio esempio ha solo un metodo utile, e quindi non è meglio di una funzione definita a livello globale, ma non appena avrai due metodi, vorrai raggrupparli insieme, giusto? Sono lontano dalla base?
Inoltre, preferisco esempi che FANNO effettivamente qualcosa, poiché a volte è difficile visualizzare quando un esempio include istruzioni come " // fai qualcosa di utile qui " che vedo continuamente quando cerco tutorial.
Ad ogni modo, mi piacerebbe ricevere feedback o commenti sul perché usare un singleton per questo tipo di cose sia dannoso (o eccessivamente complicato).
Questo articolo tratta ampiamente l'argomento: http://www.phptherightway.com/pages/Design-Patterns.html#singleton
Nota quanto segue:
- Il costruttore
__construct ()è dichiarato comeprotettoper impedire la creazione di una nuova istanza al di fuori della classe tramite l'operatorenew.- Il metodo magico
__clone ()è dichiarato comeprivateper impedire la clonazione di un'istanza della classe tramite l'operatoreclone.- Il metodo magico
__wakeup ()è dichiarato comeprivateper prevenire la non serializzazione di un'istanza della classe tramite la funzione globaleunserialize ().- Una nuova istanza viene creata tramite associazione statica tardiva nel metodo di creazione statica
getInstance ()con la parola chiavestatic. Questo consente la sottoclasse dellaclasse Singletonnell'esempio.
Ho scritto molto tempo fa pensato di condividere qui
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();
Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
/**
* Singleton class
*
*/
final class UserFactory
{
private static Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
$user_factory = UserFactory::getInstance();
Esempio di utilizzo
$user_factory = UserFactory:: Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
/**
* Singleton class
*
*/
final class UserFactory
{
private static Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
$user_factory = UserFactory::getInstance();
Esempio di utilizzo
<*>
Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>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:: Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
<*>
Esempio di utilizzo
<*>
Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>instance === null) {
self:: Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
<*>
Esempio di utilizzo
<*>
Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>instance = new UserFactory();
}
return self:: Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
<*>
Esempio di utilizzo
<*>
Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>instance;
}
}
Esempio di utilizzo
<*>
Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>instance;
class SecondUserFactory extends UserFactory { }
Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>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:: Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
<*>
Esempio di utilizzo
<*>
Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>instance === null) {
self:: Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
<*>
Esempio di utilizzo
<*>
Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>instance = new UserFactory();
}
return self:: Sono d'accordo con la prima risposta, ma vorrei anche dichiarare la classe come finale in modo che non possa essere estesa in quanto l'estensione di un singleton viola il modello singleton. Inoltre, la variabile di istanza deve essere privata in modo che non sia possibile accedervi direttamente. Rendi anche privato il metodo __clone in modo da non poter clonare l'oggetto singleton.
Di seguito è riportato un codice di esempio.
<*>
Esempio di utilizzo
<*>
Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>instance;
}
}
Esempio di utilizzo
<*>Che cosa ti impedisce di fare (che violerebbe il modello singleton ..
NON PUOI FARE QUESTO!
<*>Questo dovrebbe essere il modo giusto di Singleton.
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(){
}
}
Mi è piaciuto il metodo @ jose-segura di usare i tratti ma non mi è piaciuta la necessità di definire una variabile statica su sottoclassi. Di seguito è una soluzione che la evita memorizzando nella cache le istanze in una variabile locale statica sul metodo factory indicizzato dal nome della classe:
<?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() {}
}
L'utilizzo è lo stesso di @ jose-segura, non è necessaria la variabile statica nelle sottoclassi.
Classe di database che controlla se esiste un'istanza di database esistente che restituirà l'istanza precedente.
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]
*/
Rif. http://www.phptechi.com/php-singleton -design-patterns-example.html
Questo è l'esempio di creare singleton nella classe Database
modelli di progettazione 1) singleton
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);
quindi put put è -
object(Database)[1]
object(Database)[1]
object(Database)[1]
usa solo una singola istanza e non crea 3 istanze
Ecco il mio esempio che offre la possibilità di chiamare come $ var = new Singleton () e anche la creazione di 3 variabili per verificare se crea un nuovo oggetto:
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();
