PHP-Class-Problem

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • PHP-Class-Problem

    Hallo Community,

    ich habe ein kleines Problem. Ich fange gerade erst so richtig mit PHP an. Ich bin dabei folgendes zu realisieren:
    Eine Datei wird aufgerufen und diese startet eine Class. In dieser Class kann über c->addInstanz() eine neue (weitere) Klasse erzeugt werden. Hier der Code:

    Quellcode

    1. class construct {
    3. var $debug = array();
    5. public function createInstanz($class){
    6. if(file_exists('libary/class/' . $class . '.php')){
    7. self::addDebug($class.' included and started.');
    8. $this->{$class} = new $class;
    9. }else{
    10. self::addDebug($class.'-class not found.');
    11. }
    12. }
    14. private function addDebug($status){
    15. $this->debug[] = $status;
    16. var_dump($this->debug);
    17. }
    19. public function getDebug($format = 'Notice: <strong>%s</strong> <br />'){
    20. var_dump($this->debug);
    21. foreach($this->debug AS $message){
    22. printf($format, $message);
    23. }
    24. }
    25. }
    26. $c = new construct;
    Alles anzeigen


    Ich rufe also diese Class auf und weise diese an, eine neue zu erzeugen.

    Quellcode

    1. $c->addInstanz('user');


    Ich kann wunderbar auf die Objekte in der user-class zugreifen ($c->user->foobar() etc). Jedoch wenn ich innerhalb der user-class die Debug-Funktion nutzen will, klappt das nicht. Aufbau der user-class:

    Quellcode

    1. class user extends construct{
    3. function foobar(){
    4. $this->addDebug('tet');
    5. }
    7. }


    Der Aufruf: $c->user->foobar() funktioniert, aber wenn ich $c->getDebug() ausführe, erhalte ich nur Debug-Nachrichten aus der construct-class.

    Mein Problem ist also die Kommunikation der Classen untereinander. Da ich in Zukunft auch eine Datenbank-Class hinzufügen will, die eventuell auf Informationen aus der user-class zurückgreifen soll, weiß ich schon jetzt nicht, wie ich das anstelle, dass ich aus allen Classes in alle Classes kommunizieren kann.

    Ich hatte folgende Idee:

    Quellcode

    1. class construct{
    3. var $user = '';
    4. var $db = '';
    6. function addInstanz(&$class){
    7. // .. exists-check etc
    8. $this->user = &$class
    9. }
    11. }
    Alles anzeigen

    Dafür müsste ich aber schon jetzt alle Classes kennen, die ich irgendwann mal erzeugen würde. Und selbst dann bin ich mir über den Aufbau noch nicht so sicher, da ich nicht weiß, ob dann ein $this->db->foobar() in der user-class funktioniert.

    Wenn jemand nen Tipp hat, wie ich das umsetzte, wäre ich sehr dankbar.

    Danke & Grüße
    meme

  • Hi,

    vorweg ein paar Kleinigkeiten:
    -Du solltest deine Klasse nicht "construct" nennen. Es ist kein reserviertes Wort, aber leicht mit "__construct" welches bei PHP für den Konstruktor steht, zu verwechseln.
    -Dann ist es sinnvoll Klassennamen groß zu schreiben.
    -Wie du in deiner Funktion schon richtig geschrieben hast instanziert man eine Klasse (nicht starten).
    -Das Schlüsselwor "var" für Klassenvariablen gibt es in PHP5 nicht mehr. Dort kennzeichnest du die Klassenvariablen mit public,private oder protected.
    -Wenn du eine Klasse instanzierst, dann solltest du dir angewöhnen die Klammern zu setzen. ("new Foo()")


    Ohne es vll. zu wissen, hast du das Factory Pattern angewandt ;)


    Jetzt zu deiner Problematik.

    meme schrieb:

    Der Aufruf: $c->user->foobar() funktioniert, aber wenn ich $c->getDebug() ausführe, erhalte ich nur Debug-Nachrichten aus der construct-class.

    Wenn du $c->getDebug aufrufst, dann ist es klar, dass du nur die Debugnachricht der construct-Klasse erhälst, da diese Klasse nichts von Ihren Kindklassen weiß. Um das zu realisieren, musst du mit static arbeiten, so, dass die Debugvariable nicht immer für jede Klasse neu gesetzt wird, sondern alle die selbe Variable nutzen, dann funktioniert dein Vorhaben.


    Was du da vorhast ist nicht sonderlich schön.

    Exkurs:
    Das Factory Pattern macht Sinn, wenn man z.B eine Klasse mit mehreren Adaptern besitzt.
    Bei DB Klassen sieht man das häufig. Als Beispiel gibt es den Adapter "MySQL" der eine eigenständige Klasse darstellt. Dann kann man z.B so die DB Klasse mit dem Adapter MySQL instanzieren: $db = new DB("MySQL"); Wobei dann die Adapterklasse MySQL mittels dem Factorypattern instanziert wird.


    Besser ist es, wenn du deine Klassen eigenständig instanzierst und alles was zur Debuglogik gehört auch in die Debuggerklasse packst, denn alle anderen Klassen brauchen davon nichts wissen und die interessiert das auch nicht.
    Um das vernünftig umzusetzen brauchst du lediglich das Singleton Pattern einsetzen.


    So könnte die Implementierung aussehen :

    Quellcode

    1. <?php
    3. class Debugger
    4. {
    6. private $debugMessages = array();
    9. static private $instance = null;
    11. public static function getInstance(){
    12. if(self::$instance === null){
    13. self::$instance = new Debugger();
    14. }
    15. return self::$instance;
    16. }
    18. private function __construct() {}
    19. private function __clone() {}
    22. public function addDebugMessage($message) {
    23. $this->debugMessages[] = $message;
    24. }
    25. public function getDebugMessages() {
    26. return $this->debugMessages;
    27. }
    29. }
    32. class User
    33. {
    34. public function saveData($data = array()) {
    35. // la la la ... Programmlogik
    36. Debugger::getInstance()->addDebugMessage(get_class($this) . " says data saved");
    37. }
    38. }
    41. class DB
    42. {
    43. public function connect($host) {}
    44. public function persist($object) {
    45. // Daten in die DB schreiben ....
    46. Debugger::getInstance()->addDebugMessage(get_class($this) . " says data saved");
    47. }
    48. }
    54. $db = new DB();
    55. $db->connect("localhost");
    57. $user = new User();
    58. $user->saveData(array("username"=>"new-user-name"));
    60. $db->persist($user);
    64. $debugMessages = Debugger::getInstance()->getDebugMessages();
    66. foreach($debugMessages as $m) {
    67. echo "Nachricht: " . $m . "<br />";
    68. }
    70. // AUSGABE
    71. // Nachricht: User says data saved
    72. // Nachricht: DB says data saved
    Alles anzeigen

  • Hallo und vielen Dank für die Antwort.

    Und eine Abfrage aus User nach DB wäre so:

    Quellcode

    1. DB::getInstance()->query('BLA');

    Vorher muss ich in der DB-Class auch diesen Abfangmechanismus einbauen:

    Quellcode

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


    Kann ich dann nicht das getInstance bei den aufrufen durch das __construct-Element ersetzten? Also dass der Aufruf so wäre: DB::query("Bla") und halt in __construct der Code steht, der die Anzahl der instanzen regelt?

    meme

  • Hi,

    Möchtest du deine DB Klasse auch als Singleton implementieren ?

    Wenn ja, dann benötigt diese auch die getInstance() Methode und die statische Variable $instance. In der getInstance() Methode musst du natürlich die richtige Klasse eintragen :

    Quellcode

    1. self::$instance = new DB();
    2. // oder variabel für alle
    3. self::$instance = new self();



    Zum Verständnis vom Singleton:
    Das Singleton gewährleistet, dass von einer Klasse nur ein Objekt erzeugt werden kann.
    Quelle: phpbar.de/w/Singleton

    Du hast keine Instanzen, sondern nur 1 Instanz !
    Deshalb geht man den Weg über die getInstance-Methode, da diese Sicherstellt, das es nur 1 Instanz der Klasse gibt. Daher ist __clone und __construct auch privat so, dass von der Klasse niemals eine 2. Instanz existieren kann.


    meme schrieb:

    Und eine Abfrage aus User nach DB wäre so:
    DB::getInstance()->query('BLA');

    Was meinst du mit "einer Abfrage aus User zu DB" ?

  • Hallo Vince,

    hatte nu schnell Copy+Paste gemacht, darum stand da noch die alte Class. Mit der Abfrage meinte ich eine Anfrage/Abfrage aus der User-Class in die DB-Class (also ein Query der ausgeführt wird etc). Das Problem ist aber hinfällig bzw. gelöst.

    Ich finde diesen Aufbau sehr schön. Ich frage mich aber nun noch, warum ich alles via getInstance steuern muss und nicht __construct nehmen kann. Weil es wäre, wenn ich darauf verzichten könnte, eine kürzere Schreibweise alá DB::query('FOO').

    Eine letzte Frage, dann verschwinde ich wieder (kann mich auch mit der getInstance abfinden): Folgendes von phpbar:

    Quellcode

    1. <?php
    2. class Singleton
    3. {
    4. static private $instances = array();
    6. static public function getInstance($className) {
    7. if (!isset(self::$instances[$className])) {
    8. self::$instances[$className] = new $className();
    9. }
    10. return self::$instances[$className];
    11. }
    12. }
    14. require_once 'Girl.php';
    15. $girl = Singleton::getInstance('Girl');
    19. require_once 'Boy.php';
    20. $boy = Singleton::getInstance('Boy');
    Alles anzeigen


    Ich würde nach diesem Muster dann eine Function von (class) Boy ansteuern: Singleton::instances['Boy']->foobar(); ??

  • Hi,

    nochmal zum Konstrukt & Singleton Pattern.

    Der Konstruktor wird immer dann aufgerufen, wenn man eine Klasse instanziert.
    Wenn du eine statische Methode "query" von der Klasse "DB" aufrufen würdest, dann würde der Konstruktor NICHT aufgerufen werden. Das geschieht NUR über das "new" Keyword. Also "new DB()". Mit dem Singleton möchte man aber erreichen, das es nur EINE Instanz gibt und man diese dann über die statische Methode "getInstance" erreichen kann.

    Kleines Beispiel:

    Quellcode

    1. <?php
    3. $db = new DB();
    4. $db->connect("localhost");
    6. unset($db);
    8. // die Verbindung ist nicht mehr verfügbar, da $db gelöscht wurde
    11. ////////////////////////////////////////////////////////
    13. $db = DB::getInstance();
    14. $db->connect("localhost");
    16. unset($db);
    18. // durch das Singleton Pattern, kann die Verbindung (Resource) über die statische getInstance-Methode immer wieder geholt werden
    20. $user = DB::getInstance()->query('SELECT * FROM User'); // query ist nicht static !
    Alles anzeigen


    Du solltest zwischendurch ein bisschen "rumspielen" und testen. Schreib einfach eine Klasse mit mehreren Methoden und schaue, wann der Konstruktor überhaupt aufgerufen wird.
    Meist klären sich dadurch viele Dinge von selbst.



    meme schrieb:

    Ich würde nach diesem Muster dann eine Function von (class) Boy ansteuern: Singleton::instances['Boy']->foobar(); ??


    Die beiden Klassen sehen ja so aus:

    Quellcode

    1. class Boy extends Singleton {}
    2. class Girl extends Singleton {}


    Jein, nicht du greifst im Endeffekt auf das $instances Array der Singleton Klasse zu, sondern der Interpreter von PHP.

    Um das rumspielen von vorhin aufzugreifen.
    Setz einfach mal das Instance Array auf public und schau dir den Inhalt an.

    Quellcode

    1. <?php
    3. class Singleton
    4. {
    5. static public $instances = array();
    6. [...]
    7. }
    10. class Boy extends Singleton {}
    11. class Girl extends Singleton {}
    13. echo "Pre Girl-Boy";
    14. var_dump(Singleton::$instances);
    16. $girl = Singleton::getInstance('Girl');
    19. echo "Post Girl";
    20. var_dump(Singleton::$instances);
    22. $boy = Singleton::getInstance('Boy');
    24. echo "Post Girl-Boy";
    25. var_dump(Singleton::$instances);
    Alles anzeigen





    meme schrieb:

    Eine letzte Frage, dann verschwinde ich wieder

    du bist herzlich eingeladen dich zu registrieren :)