Frage zum richtigen Einsatz einer Regsitry

[Forumsgast]

Guten Abend an alle,

ich habe nun vieles in dem Buch PHP Design-Patterns gelesen und will nun bei einer Anwendung eine Registry einsetzen. Ich will verhindern das ich ein PDO Objekt sehr tief durch Methoden und Instanzen etc. schleifen muss.

Da bietet sich eine Registry also Globales Zugriffsobjekt ja an, soweit wie ich das gelesen habe kann man damit ein dirchreichen verhindern. Nun aber verstehe ich das eben noch nicht so ganz.

Also kurzes Beispiel, ich habe ein zentrale index.php, da werden dann Seitenbereiche über einen kleinen Page Controller geladen. Jeder dieser Seitenbereiche kann einige Klassen für verschiedenste Sachen mit sich bringen in denen ich nun Datnebankstatements absetzen muss.

Bis jetzt hbae ich das so gemacht das ich nun in der zentralen index.php eine PDO Instanz erzeugt habe und via Typehinting das Objekt an den Pae Controller übergeben habe und von dort aus dann wieder via Typehinting an andere Klassen die mit einem geladenen Seitenbereich zu tun hatten.

Das ist mir alles zuviel Durchreicherei.

Kann ich den zum Beispiel eine Registry so einsetzen?

$regsitry = new RegistryClass();

$pageController = new PageController();

$pageController->setPage( $_GET['page'] ); 

So über den Get Parameter wird nun ein Seitenbereich geladen und in Verbindung damit wieder eben andere Klassen die dann z.B. mit dem PDO Objekt arbeiten müssen.

Kann ich nun einfach in den Klassen auf mein PDO Objekt was in der Registry gespeichert ist zugreifen?

Ich hoffe ich habe mich klar ausgedrückt, wenn nicht versuche ich es noch mal.

Danke für eure Anworten Gruß Litter

[Forumsgast]

Objekte in der Registry-Klasse sind in einer Instanz der Klasse dessen Objekt in einem statischen Scope gespeichert wird. Sobald du dir die Instanz per

$db = myDatabaseRegistry::getInstance(); 

holst kannst du auf diese Instanz und deren Objekte zugreifen.

class myDatabaseRegistry {
   static private $_instance = null;

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

   private function __construct(){}
   private function __clone(){}

   private $_databaseDevice=NULL;

   public function setDatabaseDevice( mysqli $dbObj ) {
     if ( $this->_databaseDevice === NULL ) {
        $this->_databaseDevice = $dbObj;
     } else return false;
     return true;
   }
   
   public function getDatabaseDevice() {
      if ( $this->_databaseDevice === NULL ) return false;
      else return $this->_databaseDevice;
   }

} 

Usage:

$db = myDatabaseRegistry::getInstance();
$db->setDatabaseDevice(new mysqli($con,$fi, $gu,$ration));
unset($db);
$database = myDatabaseRegistry::getInstance();
$database->getDatabaseDevice()->Query("SELECT this, fields, here FROM there WHERE this='that' LIMIT 0,1"); 

Der Übersicht wegen sollte man aber mit Klassen die das Registry-Pattern verwenden sparsam umgehen.

[Forumsgast]

Ok danke erst mal, dass man damit sparsam umgehen muss weiß ich ja. Aber ich habe eben eine PDO Instantz und eine FileHandler Instanz (von einer von mir geschriebenen Klasse) und diese Sachen bracuhe ich in verschiedenen tiefen von instanzen und Klassen. Deshalb fragte ich ob das was von der Registry da kommt überall egal in welcher tiefe zugreifen kann. Das ist mir in dem Punkt wichtig weil ich dann diese wichtigen Objekte nicht durch allmögliche Methoden und tiefen via Typehinting durchschleifen muss.

[Forumsgast]

Das geht, sogar mit einer Art, ich nenns mal statische Container-Klasse

final class Keeper {
   static private $_pdo=NULL;
   static private $_file=NULL;

   public static function setPDOHandle($pdo) {
      self::$_pdo = $pdo;
   }

   public static function setFileHandle($file) {
      self::$_file = $file;
   }

   public static function getFileHandle() {
      return self::$_file;
   }

   public static function getPDOHandle() {
      return self::$_pdo;
   }
} 

Irgendwann mal per setter initialisiert kannst du egal wann und egal wo per getter auf die Objekte zugreifen, eine Instanziierung der Klasse wäre für die Katz da sie keine im Objekt-Scope liegenden Elemente enthält. Das die Objekte nicht überschrieben werden können wie bspw. es in meinem Vorposting und dem Singleton Registry deklariert wurde wäre bei so einem Einweg-Container wohl anzuraten.

[Forumsgast]

Für jedes zu speichernde Objekt ne Methode finde ich häßlich, unflexibel und auf Dauer unwartbar.

Registry::getInstance()->store ('foo' , new Foo (4711, 'test'));

..

Registry::getInstance()->restore ('foo');