Singleton esteso

[andr3a]

Originariamente inviato da whisher
@Mackey
Dai anche un occhio al design pattern
registry

il registry in singleton è un pò un controsenso ... comunque alla fine questo PHP5 non permette di sfruttare a pieno le potenzialità del pattern singleton, vuoi per problemi in serialize ed unserialize, vuoi per il mancato late bind, vuoi per l'OOP che ancora ha taaaaaaantiii problemi, ma alla fine, se uno usa una banale funzione non fa prima?

Domani ci faccio un post (sul mio blog, ovvio)

[Mackey]

Innanzitutto grazie a tutti per le risposte... sono state molto esaurienti!!

avrei trovato una soluzione... vi chiedo di dirmi se la condividete

<?php
 
class Singleton {
    private static $instanceArray = array();
 
    public function __construct() {
        $className = get_class($this);
        if(!isset(self::$instanceArray[$className])) {
            if(class_exists($className))
                self::$instanceArray[$className] = &$this;
            else {
                unset($this);
                return NULL;
            }
        }
        else {
            print "già instanziata";
            //$this = self::$instanceArray[$className];
        }
        return self::$instanceArray[$className];
    }
 
    public static function getClassInstance($className = false) {
        if(!$className)
            return NULL;
        if(!isset(self::$instanceArray[$className])) {
            if(class_exists($className))
                self::$instanceArray[$className] = new $className();
            else
                return NULL;
        }
        return self::$instanceArray[$className];
    }
 
    public static function test() {
        print "<pre>".print_r(self::$instanceArray, true)."</pre>";
    }
}
 
 
 
 
class A extends Singleton {
    public $prova;
    public function setProva($newValue) {
        $this->prova = $newValue;
    }
}
 
 
 
class B extends Singleton {
 
}
 
 
 
 
 
//$a = new A();
$a = A::getClassInstance("A");
 
$a->setProva("Stringa da sovrascrivere");
 
//$a2 = new A();
$a2 = A::getClassInstance("A");
$a2->setProva("Stringa sovrascrivente");
 
$a->test();
$a2->test();
 
//$b = new B();
$b = B::getClassInstance("B");
$b->test();
 
 
$a2->test();
 
 
?>

[andr3a]

non male, ma se hai un metodo pubblico statico che richiede il nome della classe, a cosa ti serve estendere quella classe?

[Mackey]

Estendo la classe perché il Sigleton lo utilizzo tipo "interfaccia"... in effetti ora che ci penso... utilizzandolo proprio come interfaccia migliora qualcosa?

Comunque tornando alla risposta... io ho una classe Scuola ad esempio, che estende Singleton... a quel punto Scuola è automaticamente Singleton... così come per Scuola immaginalo per altre 30 o 40 classi.

piuttosto però se guardi il codice, a un certo punto del costruttore vedi:

else {
            print "già instanziata";
            //$this = self::$instanceArray[$className];
        } 

siccome $this non si può riassegnare,
premesso che

$a = new A();
$a2 = new A();

come faccio a dire che

$a e $a2 sono la stessa istanza?

[Razorblade]

Se per te non è un problema usare questo genere di sintassi per istanziare una classe singleton

$miaClasse = Loader::load('MiaClasse'); 

puoi usare il metodo che ti avevo già segnalato che tra l'altro è utilizzato da diversi framework più o meno famosi.
In pratica crei una classe statica Loader ( o Singleton o come vuoi tu ) e per istanziare una classe singleton richiami un metodo statico, load in questo caso, ma può essere quello che vuoi tu ( getInstance per esempio ).
La classe statica al suo interno ha un array dove vengono tenute in memoria le classi già istanziate, che saranno restituite in caso si nuova chiamata.

[Mackey]

finalmente ci sono arrivato...

quindi in linea di massima dovrebbe essere così?

<?php
 
class Singleton {
    private static $instanceArray = array();
 
    private function __construct() {}
 
    public static function load($className = false) {
        if(!$className)
            return NULL;
        if(!isset(self::$instanceArray[$className])) {
            if(class_exists($className))
                self::$instanceArray[$className] = new $className();
            else
                return NULL;
        }
        return self::$instanceArray[$className];
    }
 
    public static function test() {
        print "<pre>".print_r(self::$instanceArray, true)."</pre>";
    }
}
 
 
 
 
class A {
    public $prova;
    public function setProva($newValue) {
        $this->prova = $newValue;
    }
}
 
 
 
class B {
 
}
 
 
 
$a = Singleton::load("A");
 
$a->setProva("Stringa da sovrascrivere");
 
$a2 = Singleton::load("A");
$a2->setProva("Stringa sovrascrivente");
 
Singleton::test();
 
$b = Singleton::load("B");
 
Singleton::test();
 
 
?>

[Razorblade]

Dovrebbe andare bene
Provala così adesso:

  abstract class DinamicSetterGetter
  {
    function __call($method, $arguments) {
      $prefix = strtolower(substr($method, 0, 3));
      $property = strtolower(substr($method, 3));
      if (empty($prefix) || empty($property)) {
        return;
      }
      if ($prefix == "get" && isset($this->$property)){
        return $this->$property;
      }else if ($prefix == "set"){
        $this->$property = $arguments[0];
        return $this;
      }
    }
  }
 
  class A extends DinamicSetterGetter {
      public $prova;
  } 

[andr3a]

eccomi qua

[Razorblade]

Ciao Andrea,
ho letto parte del post sul tuo blog, ho qualche domanda:

1) Il perchè della seguente affermazione:

In a lot of frameworks, as in a lot of libraries, I have seen every kind of Singleton implementation, and most of them, are conceptually hilarious

Che cos'hanno di divertente?

2) Premettendo che mi sono informato abbastanza sul metodo magico __clone e sulle tecniche di clonazione di un oggetto ( shallow e deep copy ), mi piacerebbe avere una ulteriore spiegazione e magari un esempio pratico, se possibile, a proposito di questa affermazione

if there's no magic __clone method, it does not make sense

3) Per implementare il pattern singleton vi è la necessità di utilizzare __callStatic?

Leggerò il resto del tuo interessantissimo post appena avrò chiari questi concetti.
Ciao

[whisher]

Originariamente inviato da andr3a
eccomi qua

il return $this ha qualche scopo a me
sconosciuto perchè nell'esempio è
superfluo o sbaglio ?

function Singleton($__CLASS__){
    // webreflection.blogspot.com
    static  $list = array();
    if(!isset($list[$__CLASS__])){
        $arguments = func_get_args();
        array_shift($arguments);
        $instance = new ReflectionClass($__CLASS__);
        $list[$__CLASS__] = !is_null($instance->getConstructor()) ? $instance->newInstanceArgs($arguments) : $instance->newInstance();
    }
    return  $list[$__CLASS__];
}
class A {
    protected $value = '123';
    function write($what){
        echo $what.$this->value;
        //return  $this;
    }
}
class B extends A {
    function __construct($value){
        $this->value = $value;
    }
}
Singleton('A', 'my value')->write('Hello World'); 

ho aggiunto il is_null
d'accordo che php è loose type
ma quando si può