Creando el patrón de diseño Singleton en PHP5
https://stackoverflow.com/questions/203336
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Cómo crear una clase Singleton usando las clases PHP5?
Solución
/**
* 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()
{
}
}
Para usar:
$fact = UserFactory::Instance();
$fact2 = UserFactory::Instance();
$ fact == $ fact2;
Pero:
$fact = new UserFactory()
lanza un error.
Ver http://php.net/manual/en/language.variables.scope.php#language.variables.scope.static para comprender los ámbitos de las variables estáticas y por qué configurar static $ inst = nulo; funciona.
Otros consejos
PHP 5.3 permite la creación de una clase Singleton heredable mediante un enlace estático tardío:
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;
}
}
Esto resuelve el problema, que antes de PHP 5.3 cualquier clase que extendiera un Singleton produciría una instancia de su clase principal en lugar de la suya propia.
Ahora puedes hacerlo:
class Foobar extends Singleton {};
$foo = Foobar::getInstance();
Y $ foo será una instancia de Foobar en lugar de una instancia de Singleton.
Desafortunadamente La respuesta de Inwdr se interrumpe cuando hay subclases multiples.
Aquí hay una clase base de Singleton heredable correcta.
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];
}
}
Código de prueba:
class Foo extends Singleton {}
class Bar extends Singleton {}
echo get_class(Foo::getInstance()) . "\n";
echo get_class(Bar::getInstance()) . "\n";
La forma real y moderna de hacer Singleton Pattern es:
<?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() {}
}
Así que ahora puedes usarlo como.
<?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
Como ves, esta realización es mucho más flexible.
Probablemente debería agregar un método privado __clone () para no permitir la clonación de una instancia.
private function __clone() {}
Si no incluye este método, es posible obtener lo siguiente
$inst1=UserFactory::Instance(); // to stick with the example provided above
$inst2=clone $inst1;
ahora $ inst1 ! == $ inst2 - ya no son la misma instancia.
<?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(){
}
}
utilizar:
/**
* 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) {
}
Si está utilizando PHP 5.4: trait es una opción, por lo que no tiene que perder la jerarquía de herencia para tener Patrón de Singleton
y también observa que si usas traits o amplía Singleton clase un extremo suelto fue crear un singleton de clases secundarias si no agrega la siguiente línea de código:
protected static $inst = null;
en la clase secundaria
el resultado inesperado será:
object(DBFactoryChild)#1 (0) {
}
object(DBFactoryChild)#1 (0) {
}
protected static <*>
Este código puede aplicarse a cualquier clase sin preocuparse por su nombre de clase.
instance;
public static function getInstance()
{
if(is_null(self::<*>
Este código puede aplicarse a cualquier clase sin preocuparse por su nombre de clase.
instance))
{
self::<*>
Este código puede aplicarse a cualquier clase sin preocuparse por su nombre de clase.
instance = new self();
}
return self::<*>
Este código puede aplicarse a cualquier clase sin preocuparse por su nombre de clase.
instance;
}
Este código puede aplicarse a cualquier clase sin preocuparse por su nombre de clase.
Admite varios objetos con 1 línea por clase:
Este método impondrá singletons en cualquier clase que desee, todo lo que tiene que hacer es agregar 1 método a la clase que desea crear un singleton y esto lo hará por usted.
Esto también almacena objetos en un " SingleTonBase " clase para que pueda depurar todos los objetos que ha utilizado en su sistema recurriendo los objetos SingleTonBase .
¡Cree un archivo llamado SingletonBase.php e inclúyalo en la raíz de su script!
El código es
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;
}
}
Luego, para cualquier clase que desee hacer un singleton, simplemente agregue este pequeño método único.
public static function Singleton()
{
return SingletonBase::Singleton(get_class());
}
Aquí hay un pequeño ejemplo:
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();
Y puedes agregar esta función de singleton en cualquier clase que tengas y solo creará 1 instancia por clase.
NOTA: Siempre debe hacer que __construct private para eliminar el uso de new Class (); instanciaciones.
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();
Realmente no necesitas usar el patrón Singleton porque se considera que es un antipatrón. Básicamente, hay muchas razones para no implementar este patrón en absoluto. Lea esto para comenzar con: Mejores prácticas en las clases de PHP singleton .
Si después de todo aún piensa que necesita usar el patrón de Singleton, podríamos escribir una clase que nos permita obtener la funcionalidad de Singleton extendiendo nuestra clase abstracta SingletonClassVendor.
Esto es con lo que vine para resolver este 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() {}
}
Ejemplo de 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 para demostrar que funciona como se esperaba:
/**
* 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
Toda esta complejidad (" vinculación estática tardía " ... harumph) es, para mí, simplemente un signo del modelo de clase / objeto roto de PHP. Si los objetos de clase eran objetos de primera clase (consulte Python), entonces " $ _ instance " sería una variable de instancia de clase - un miembro del objeto de clase, a diferencia de un miembro / propiedad de sus instancias, y también a diferencia de compartido por sus descendientes. En el mundo de Smalltalk, esta es la diferencia entre una " variable de clase " y una " variable de instancia de clase " ;.
En PHP, me parece que debemos tomarnos en serio la guía de que los patrones son una guía para escribir código; quizás podríamos pensar en una plantilla de Singleton, pero al intentar escribir un código que se hereda de un " ; Singleton " La clase parece estar mal orientada para PHP (aunque supongo que un alma emprendedora podría crear una palabra clave SVN adecuada).
Continuaré simplemente codificando cada singleton por separado, usando una plantilla compartida.
Tenga en cuenta que estoy absolutamente fuera de la discusión de singletons-are-evil, la vida es demasiado corta.
Sé que esto probablemente causará una guerra de llamas innecesaria, pero puedo ver cómo es posible que desee más de una conexión de base de datos, por lo que le concederé el hecho de que Singleton podría no ser la mejor solución para eso ... sin embargo , hay otros usos del patrón de singleton que me parecen extremadamente útiles.
Aquí hay un ejemplo: decidí rodar mi propio MVC y el motor de plantillas porque quería algo realmente ligero. Sin embargo, los datos que quiero mostrar contienen una gran cantidad de caracteres matemáticos especiales como = y µ y lo que tienen ... Los datos se almacenan como el carácter UTF-8 real en mi base de datos en lugar de en codificación pre-HTML porque Mi aplicación puede entregar otros formatos como PDF y CSV además de HTML. El lugar apropiado para formatear para HTML está dentro de la plantilla (" vista " si lo desea) que es responsable de representar esa sección de la página (fragmento). Quiero convertirlos a sus entidades HTML apropiadas, pero la función get_html_translation_table () de PHP no es súper rápida. Tiene más sentido recuperar los datos una vez y almacenarlos como una matriz, haciéndolos disponibles para que todos los usen. Aquí hay una muestra que junté para probar la velocidad. Presumiblemente, esto funcionaría independientemente de si los otros métodos que usa (después de obtener la instancia) fueron estáticos o no.
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";
Básicamente, vi resultados típicos como este:
php test.php Run time: 27.842966794968 seconds using singleton Run time: 237.78191494942 seconds without using singleton
Entonces, aunque ciertamente no soy un experto, no veo una manera más conveniente y confiable de reducir la sobrecarga de las llamadas lentas para algún tipo de datos, al mismo tiempo que es súper simple (una sola línea de código para hacer lo que usted necesita). necesitar). De acuerdo, mi ejemplo solo tiene un método útil y, por lo tanto, no es mejor que una función definida globalmente, pero tan pronto como tenga dos métodos, querrá agruparlos, ¿verdad? ¿Estoy fuera de la base?
También, prefiero los ejemplos que realmente HACEN algo, ya que a veces es difícil de visualizar cuando un ejemplo incluye declaraciones como " // hacer algo útil aquí " que veo todo el tiempo cuando busco tutoriales.
De todos modos, me encantaría cualquier comentario o comentario sobre por qué el uso de un singleton para este tipo de cosas es perjudicial (o demasiado complicado).
Este artículo cubre el tema bastante extensamente: http://www.phptherightway.com/pages/Design-Patterns.html#singleton
Tenga en cuenta lo siguiente:
- El constructor
__construct ()se declara comoprotectedpara evitar la creación de una nueva instancia fuera de la clase a través del operadornew.- El método mágico
__clone ()se declara comoprivatepara evitar la clonación de una instancia de la clase a través del operadorclone.- El método mágico
__wakeup ()se declara comoprivatepara evitar la deserialización de una instancia de la clase a través de la función globalunserialize ().- Se crea una nueva instancia a través del enlace estático tardío en el método de creación estática
getInstance ()con la palabra clavestatic. Esta permite la subclase declass Singletonen el ejemplo.
He escrito hace mucho tiempo para compartir aquí
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();
Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
/**
* Singleton class
*
*/
final class UserFactory
{
private static Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
$user_factory = UserFactory::getInstance();
Ejemplo de uso
$user_factory = UserFactory:: Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
/**
* Singleton class
*
*/
final class UserFactory
{
private static Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
$user_factory = UserFactory::getInstance();
Ejemplo de uso
<*>
Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>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:: Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
<*>
Ejemplo de uso
<*>
Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>instance === null) {
self:: Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
<*>
Ejemplo de uso
<*>
Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>instance = new UserFactory();
}
return self:: Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
<*>
Ejemplo de uso
<*>
Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>instance;
}
}
Ejemplo de uso
<*>
Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>instance;
class SecondUserFactory extends UserFactory { }
Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>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:: Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
<*>
Ejemplo de uso
<*>
Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>instance === null) {
self:: Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
<*>
Ejemplo de uso
<*>
Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>instance = new UserFactory();
}
return self:: Estoy de acuerdo con la primera respuesta, pero también declararía que la clase es definitiva, por lo que no se puede extender ya que la extensión de un singleton viola el patrón de singleton. Además, la variable de instancia debe ser privada para que no se pueda acceder directamente. También haga que el método __clone sea privado para que no pueda clonar el objeto singleton.
A continuación hay un código de ejemplo.
<*>
Ejemplo de uso
<*>
Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>instance;
}
}
Ejemplo de uso
<*>Lo que esto te impide hacer (lo que violaría el patrón de singleton ..
¡NO PUEDES HACER ESTO!
<*>Esta debería ser la forma correcta de 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(){
}
}
Me gustó el método @ jose-segura de usar rasgos, pero no me gustó la necesidad de definir una variable estática en las subclases. A continuación se muestra una solución que evita el almacenamiento en caché de las instancias en una variable local estática al método de fábrica indexado por nombre de clase:
<?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() {}
}
El uso es el mismo que @ jose-segura, sin necesidad de la variable estática en las subclases.
Clase de base de datos que comprueba si hay alguna instancia de base de datos existente que devolverá la instancia anterior.
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
Este es el ejemplo de crear singleton en la clase Base de datos
patrones de diseño 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);
entonces fuera de lugar es -
object(Database)[1]
object(Database)[1]
object(Database)[1]
utilice solo una instancia, no cree 3 instancias
Este es mi ejemplo que proporciona la capacidad de llamar como $ var = new Singleton () y también crea 3 variables para probar si crea un nuevo objeto:
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();
