Singleton: implementacion

[Italico76]

He visto innumerables implementaciones de Singleton...todas diferentes...

Código PHP:

  Class Singleton {

  /* 
    Primero se crea la instancia y se imprime 'Hey',
  e inmediatamente luego se ejecuta el constructor,
  imprimiendose ' boy!'
  */
  public function __construct(){
    echo ' boy!';
  }

  static function arranque(){
    static $instancia = 0;  
  
   // podria haber chequeado: !is_object($instancia)
    if (!($instancia instanceof singleton)){
      echo 'Hey';
      $instancia = new singleton;
    }    
  }  

} #

/* Imprime SOLO UNA VEZ: Hey boy */
$x = singleton :: arranque();
$x = singleton :: arranque();
$x = singleton :: arranque();  
   

La de arriba es mia...pero aca otra... por ejemplo:

Código PHP:

  <?
class Database 
{ 
    // Store the single instance of Database 
    private static $m_pInstance; 

    private function __construct() { 
      echo 'Test ..';
    } 

    public static function getInstance() 
    { 
        if (!self::$m_pInstance) 
        { 
            self::$m_pInstance = new Database(); 
        } 

        return self::$m_pInstance; 
    } 
}   

Mi duda: la puedo hace de CUALQUIER forma ? (mas alla de evitar clonacion del objeto, etc) o hay ventajas ? GRACIAS!

[jahepi]

Hola Italico76 !

Con que entiendas conceptuálmente cual es el propósito del patrón la implementación puede variar de muchas formas.

Cito de la wikipedia, que fue lo primero que encontré :

Su intención consiste en garantizar que una clase sólo tenga una instancia y proporcionar un punto de acceso global a ella.

En cuanto a la implementación de la primera opción veo un detalle y es que tienes el constructor público, alguien que utilice la clase, accidentalmente podría crear "n" instancias sin saberlo.

Un saludo y suerte !

[masterpuppet]

Hay algunos puntos a tener en cuenta a la hora de hacer un singleton en PHP,

Obligatorio

1. El constructor debe ser privado
2. La clase debe sobrescribir __clone

Opcional

1. Por lo general el metodo que para obtener el objeto se denomina getInstance

Código PHP:

class Singleton 
{ 
 
    private static $_instance; 
 
    private function __construct() 
    {} 
 
    public static function getInstance() 
    { 
        if (!self::$_instance) { 
            self::$_instance = new self; 
        } 
        return self::$_instance; 
    } 
 
    private function __clone()
    {}
}
 

Ten en cuenta que es considerado por muchos(me incluyo) un anti-pattern y utilizarlo para la conexión a la bbdd es una pesima idea(esto te lo comento porque la clase de ejemplo es Database).

Saludos.

[GatorV]

Respecto al código que expones, la primera versión no es totalmente POO, ya que el operador static sobre una variable solo hace que esa variable sea estatica y se usaba cuando haces funciones, no en POO.

En POO se usa una versión como indica @masterpuppet.

Saludos.

[Italico76]

jahepi: ahora caigo en cuentas del private del __contruct() que ademas previene que la clase pueda ser heredada (creo) .. gracias

Respecto al código que expones, la primera versión no es totalmente POO, ya que el operador static sobre una variable solo hace que esa variable sea estatica y se usaba cuando haces funciones, no en POO.

Pues..gracias! la verdad pensandolo un poco....tienes razon! no es una propiedad sino una variable "local" no-local

Una cosa..... y es que me confunde horrible la sintaxis que usa masterpuppet... con eso de new self por ejemplo... que son cosas que no se ven tan seguido (o yo no las veo)

Es que hay una sintaxis casi especifica para Singleton ? o... se puede hacer bien.... usando funciones como is_object() o get_instance() ?

Devolver el objeto es para poder usar metodos encadenados o... hay alguna otra razon ?

Nuevamente gracias!

[GatorV]

self, siempre se refiere a la misma clase, es lo mismo que usar new Clase(), pero dentro de la clase y como estas implementando singleton, vas a devolver la misma instancia, por eso es igual usar new self();

is_object no se puede usar, ya que solo comprueba si la variable es un objeto, y tienes que comprobar si mas bien la variable es una instancia de la clase.

get_instance desconozco que hace esa función.

No hay una sintaxis obligatoria, simplemente es que en tu primera llamada a getInstance() si la instancia de la clase no existe la cree y la devuelva.

Podrías usar algo así también:

Código PHP:

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

Saludos.

[Italico76]

Iniciado por GatorV

is_object no se puede usar, ya que solo comprueba si la variable es un objeto, y tienes que comprobar si mas bien la variable es una instancia de la clase.

Pero......... quien va a meter la instancia de otra clase en una variable private ?

Otra cosa... si el constructor es privado... se podria heredar....... o estoy mal ?

[GatorV]

Es más limpio si compruebas si la instancia es de la misma clase, es la idea del patrón, que te garantice una sola instancia de esa clase.

No, si es private no lo puedes heredar, de hecho el patrón singleton no se debe de heredar, ya que como lo indica el patrón, es para garantizar una instancia de esa clase.

Saludos.

[Italico76]

A eso iva...

Si el constructor es private ... usar is_objet() pasa a ser valido

[GatorV]

Pues no, porque que tal si en algún punto de tu clase cambia self::$_instance por otra cosa, tendrías un error:

Código PHP:

class Singleton
{
       private static $_instance = null;
 
       private function __construct(){}
 
       public static function getInstance()
       {
              if(!(self::$_instance instanceof self)) {
                      self::$_instance = new self();
              }
 
              return self::$_instance;
       }
 
       private function __clone() {}
 
       public function hijackInstance()
       {
              self::$_instance = new stdClass();
       }
}
 
$instance = Singleton::getInstance();
var_dump($instance);
$instance->hijackInstance();
var_dump($instance);
 

Corre ese código como esta, y reemplaza el chequeo por is_object y puedes ver donde tienes un problema.

La idea del patrón es que sea un punto único de entrada, digamos un constructor único por instancia.

Saludos.

[masterpuppet]

Si bien la idea es que haya una única instancia de una clase, el esqueleto del singleton es siempre el mismo, y puede ser una opción extender de una clase base a otras que quieras que sean Singleton's, esto dentro de la teoria, como dije antes no me agrada Signleton, solo que para lograrlo vas a depender de la versión de PHP, Late Static Binding esta disponible recien a partir de PHP 5.3+, y hay que hacer unos ajustes, algo asi:

Código PHP:

class Singleton 
{ 
    protected static $_instance = null; 
 
    private function __construct() 
    {} 
 
    public static function getInstance() 
    { 
        if (null === static::$_instance) { 
            static::$_instance = new static; 
        } 
        return static::$_instance; 
    } 
 
    private function __clone()
    {}
}
 
class SimpleSingleton extends Singleton
{
    protected static $_instance = null;
}
 

Con respecto a la sintaxis, yo no veo nada extraño, a que le dices "horrible" ?

[Italico76]

"Horrible" es mi entendimiento

masterpuppet: gracias por todos tus valiosos comentarios y lo mismo para GatorV que siempre esta dispuesto a ayudar

[jahepi]

A modo off-topic, relacionado con lo que ha dicho masterpuppet.

Muchos consideran el patrón singleton un anti-patrón por que muchos caen en el error de tratar de emular el uso de las variables globales, lo cual en la OOP es algo que debemos evitar a toda costa, uno de los grandes problemas es la ocultación de las dependencias, por ejemplo, un método puede que utilice un variable singleton pero en la declaración no nos informa absolutamente nada de esa dependencia, tendríamos que inspeccionar el código para darnos cuenta, ahora imagina si la misma regla aplica no a una si no a cientos de clases, hace sumamente difícil depurar el código.

Otro punto importante es la reusabilidad, puede que queramos utilizar una clase en otro proyecto pero al no saber que depende de un singleton pues ya sabrás las consecuencias iníciales.

Utiliza singleton si es necesario, usa "la inyección de dependencias" en las clases que utilicen el singleton para evitar los dolores de cabeza antes mencionados.

Un saludo y suerte !

[bigwhite]

Muy bueno lo de "la inyección de dependencias" .... !