Registre ou motif Singleton en PHP?

Question

Je travaille avec des classes et des objets PHP maintenant. Dans cette question, les noms des champs et des méthodes sont inventés juste pour que vous ayez une idée de ce dont je parle.

Il est lié à l'utilisation des modèles de conception de singleton et de registre. Maintenant, disons que je dois accéder à un objet Database, un objet Cache, un objet Core Settings, un objet Session dans presque toutes les autres classes auxquelles j'aurai besoin d'accéder. Donc, je voudrais utiliser un registre pour stocker tous les 4 de ces objets dans 1 objet de classe de registre. Je pourrais alors simplement passer mon objet dans un autre objet qui doit y accéder. Donc ça sonne bien jusqu'ici mais que se passe-t-il si j'ai des classes qui n'ont pas besoin de tous ces 4 objets, que dois-je faire pour accéder à l'objet Database ou à l'objet Session dans certaines de mes autres classes? Pour perfromance serait-il préférable de simplement utiliser un singleton à l'intérieur de ces autres objets ou serait-il le même d'aller de l'avant et d'utiliser mon registre dans ceux-ci? Je ne sais pas assez comment les objets fonctionnent en PHP pour savoir s'il y aurait un gain de performance (moins d'utilisation de la mémoire, de l'utilisation du processeur, du temps de chargement). Donc, toute personne ayant de l'expérience dans ce domaine peut me dire s'il y aurait un gain en utilisant l'un ou l'autre, je suis au stade où je peux aller de l'autre sans affecter le temps de production ou quoi que ce soit. Je voudrais utiliser la meilleure méthode si je peux maintenant.

Answer 1

Cela dépend de votre application. Si vous avez toujours besoin de 3 classes sur 4, alors il serait plus idéal d'utiliser le registre que de gérer les 3 indépendamment seulement parce que vous n'avez pas besoin du quatrième. Charger les classes paresseusement serait une approche pour réduire l'empreinte de la mémoire, mais ensuite vous devez indiquer au registre quand créer les objets et ce n'est pas très différent de la manipulation des singletons. Vous pouvez également créer un constructeur à n paramètres ou utiliser un tableau pour indiquer au registre les classes à instancier pendant la construction. Puis instanciez votre registre en spécifiant les classes à instancier.

class Registry { 
    public $class1; 
    public $class2; 

    function __construct($uses) { 
     foreach($uses as $class) { 
      $this->{$class} = new {$class}(); 
     } 
    } 

} 

$reg = new Registry(array('class1')); 

Vous voudriez évidemment que votre constructeur gère les paramètres zéro pour prendre en compte l'instanciation de toutes les classes par défaut.

Answer 2

Vous pouvez implémenter vous avez vraiment besoin de chargement paresseux pour charger uniquement les objets:

class Registry 
{ 
    private static $database = null; 

    private static function connectDatabase($key) 
    { 
     [... do connection stuff ...] 
    } 

    public static function getDatabase($key) 
    { 
     if (Registry::$database == null) 
     { 
      Registry::connectDatabase($key); 
     } 
     return Registry::$database; 
    } 
} 

Le code pour enregistrer les paramètres de connexion de base est laissée comme exercice pour le lecteur.

Answer 3

C'est peut-être le modèle Singleton-Registry approprié. OFC, vous pouvez implémenter différentes choses, SplFixedArray, ArrayAccess interface, et d'autres. Aussi, il n'est pas mauvais d'ajouter la destruction et de détruire les objets internes pour éviter toute fuite. J'ai trouvé une question

class oRegistry{ 
    private static $instance = null; 

    private $storage = array(); 

    private function __construct(){} 

    private function __clone(){} 

    public static function getInstance(){ 
     if(self::$instance === null){ 
     self::$instance = new self(); 
     } 
     return self::$instance; 
    } 

    public function attach($name, $o) { 
     if(true === isset($this->storage[$name])) { 
      throw new Exception('The instance with name '.$name.' already exists in registry.'); 
     } 
     if(!empty($name)) { 
      $this->storage[ $name ] = $o; 
     } 
    } 

    public function detach($name){ 
     if(isset($this->storage[ $name ])) { 
      $this->storage[ $name ] = null; 
      unset($this->storage[ $name ]); 
     } 
    } 

    public function get($name){ 
     if(false === isset($this->storage[$name])) { 
      throw new Exception('Invalid instance requested'); 
     } 
     return $this->storage[ $name ]; 
    } 
} 

// usage example 
$storage = oRegistry::getInstance(); 
$obj = new stdClass; 
$obj2 = new stdClass; 
$obj->test1 = 'test'; 
$obj2->test2 = 't2'; 

$storage->attach('test1', $obj); 
$storage->attach('test2', $obj2); 

$got = $storage->get('test2'); 
var_dump($got); // object(stdClass)#3 (1) { ["test2"]=> string(2) "t2" } 

$storage->detach('test2'); 
$got = $storage->get('test2'); 
var_dump($got); // bool(false)