Objektorientiertes Programmieren

Bei diesem Tutorial geht es darum die Wirkungsweise von OOP (objetktorientiertes Programmieren) verständlich zu machen. Angenommen unser Problem besteht innerhalb eines Projektes darin mehrere Datenbanken ansprechen zu müssen. Da läßt sich per OOP eine leichte Lösung finden. Wir schreiben dafür eine Klassendatei mit dem Namen class_datenbank.php.

als erstes die Klasse an sich

in der Variablen $dbname wird der Datenbankname, der beim Erzeugen der Instanz übergeben wird, gespeichert. Außerdem setzen wir gleich noch den Datenbankhost, Datenbankbenutzername und Datenbankpasswort. (hier bitte die richtigen Werte einsetzen, sonst gibts ne Fehlermeldung)


 1 
 2 <?php
 3 class datenbank {
 4 
 5  // Datenbankhost
 6  var $host = 'localhost';
 7 
 8  // Datenbankbenutzername
 9  var $user = 'admin';
10 
11  // Datenbankpasswort
12  var $passwort = 'projekt';
13 
14  // Datenbankname speichern
15  var $dbname = '';
16 
17  function datenbank( $name) {
18   // diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
19   // Datenbankname in $dbname speichern
20   $this->dbname = $name;
21  }
22 }
23 ?>
24 


dann als nächstes wird beim Initialisieren der Klasse überprüft, ob wir schon eine Verbindung zum Datenbankserver haben, wenn nicht wird eine hergestellt. Dafür verwenden wir eine Variable außerhalb der Klasse $verbindung, diese muß jedoch innerhalb der Funktionen mit -global- eingebunden werden, wird also für die Funktion innerhalb einer Klasse sichtbar und kann verwendet und verändert werden. neu hinzu gekommenes steht in gestrichelten Linien


 1 
 2 <?php
 3 // -----------------------
 4 // hier die Variable in der wir speichern ob wir schon eine 
 5 // Datenbankverbindung haben, gleichzeitig nutzen wir diese als 
 6 // Verbindungskennung um unsere Datenbanken anzusprechen
 7 $verbindung = NULL;
 8 // -----------------------
 9 
10 class datenbank {
11 
12  // Datenbankhost
13  var $host = 'localhost';
14 
15  // Datenbankbenutzername
16  var $user = 'admin';
17 
18  // Datenbankpasswort
19  var $passwort = 'projekt';
20 
21  // Datenbankname speichern
22  var $dbname = '';
23 
24  function datenbank( $name) {
25   // diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
26 
27   // ------------------------
28   // Variable $verbindung mit global einbinden
29   global $verbindung;
30   // ------------------------
31 
32   // Datenbankname in $dbname speichern
33   $this->dbname = $name;
34  
35  // ------------------------
36  // abfragen ob Verbindung zum Server bereits besteht, wenn nicht
37 // Verbindung herstellen
38  if(!$verbindung) $verbindung = @mysql_connect( $this->host, $this->user, $this->passwort);
39  
40  // haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
41  if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
42  // ------------------------
43  }
44 }
45 ?>
46 


Jetzt noch die Funktion die eine Verbindung zu der Datenbank selber herstellt. Der Grund warum wir diese Funktion extra aufrufen werden wir weiter unten lesen. Vor dem Verbinden überprüfen wir noch welche Datenbank grade aktiv ist, wenn die schon aktiv ist die wir wollen, brauchen wir die Datenbank nicht mehr verbinden (spart Rechenzeit), dazu definieren wir noch eine Variable, die außerhalb der Klasse liegt.


 1 
 2 <?php
 3 // hier die Variable in der wir speichern ob wir schon eine 
 4 // Datenbankverbindung haben, gleichzeitig nutzen wir diese als 
 5 // Verbindungskennung um unsere Datenbanken anzusprechen
 6 $verbindung = NULL;
 7 
 8 // --------------------------
 9 $dbaktiv = '';
10 // --------------------------
11 
12 class datenbank {
13 
14  // Datenbankhost
15  var $host = 'localhost';
16 
17  // Datenbankbenutzername
18  var $user = 'admin';
19 
20  // Datenbankpasswort
21  var $passwort = 'projekt';
22 
23  // Datenbankname speichern
24  var $dbname = '';
25 
26  function datenbank( $name) {
27   // diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
28 
29   // Variable $isverbindung mit global einbinden
30   global $verbindung;
31 
32   // Datenbankname in $dbname speichern
33   $this->dbname = $name;
34  
35   // abfragen ob Verbindung zum Server bereits besteht, wenn nicht Verbindung herstellen
36   if(!$verbindung) $verbindung = @mysql_connect( $this->host, $this->user, $this->passwort);
37  
38   // haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
39   if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
40 
41  }
42 
43 // -----------------------------
44 // hier die Funktion die eine Verbindung zu einer Datenbank herstellt
45  function connect_db( $name) {
46 
47   // Variable $verbindung und $dbaktiv einbinden
48   global $verbindung, $dbaktiv;
49 
50   // Datenbank $name Verbindung herstellen
51   $result = @mysql_select_db( $name, $verbindung);
52 
53   // haben wir Datenbankverbindung? wenn nein Fehlermeldung
54   if(!$result) die("Datenbank ".$name." nicht vorhanden.");
55 
56   // Datenbankverbindung besteht, aktuellen Datenbanknamen in $dbaktiv speichern
57   else $dbaktiv = $name;
58  }
59 // -----------------------------
60 }
61 ?>
62 


Dann brauchen wir noch eine Funktion, die die SQL-Abfragen selbst bearbeitet. Das besondere ist aber, daß diese Funktion zuerst abfragt, mit welcher Datenbank wir verbunden sind, es wird also die aktuelle mit der verglichen, die wir ansprechen wollen. Ist nicht die aktiv die wir haben wollen (wir haben ja den Datenbank-Namen mit Instanzieren der Klasse in $dbname gespeichert) rufen wir die Funktion connect_db() auf.


 1 
 2 <?php
 3 // hier die Variable in der wir speichern ob wir schon eine 
 4 // Datenbankverbindung haben, gleichzeitig nutzen wir diese als 
 5 // Verbindungskennung um unsere Datenbanken anzusprechen
 6 $verbindung = NULL;
 7 $dbaktiv = '';
 8 
 9 class datenbank {
10 
11  // Datenbankhost
12  var $host = 'localhost';
13 
14  // Datenbankbenutzername
15  var $user = 'admin';
16 
17  // Datenbankpasswort
18  var $passwort = 'projekt';
19 
20  // Datenbankname speichern
21  var $dbname = '';
22 
23  function datenbank( $name) {
24   // diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
25 
26   // Variable $verbindung mit global einbinden
27  global $verbindung;
28 
29   // Datenbankname in $dbname speichern
30   $this->dbname = $name;
31  
32   // abfragen ob Verbindung zum Server bereits besteht, wenn nicht Verbindung herstellen
33   if(!$verbindung) $verbindung = @mysql_connect( $this->host, $this->user, $this->passwort);
34  
35   // haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
36   if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
37 
38  }
39 
40  // hier die Funktion die eine Verbindung zu einer Datenbank herstellt
41  function connect_db( $name) {
42   // Variable $verbindung und $dbaktiv einbinden
43   global $verbindung, $dbaktiv;
44 
45   // Datenbank $name Verbindung herstellen
46   $result = @mysql_select_db( $name, $verbindung);
47 
48   // haben wir Datenbankverbindung? wenn nein Fehlermeldung
49   if(!$result) die("Datenbank ".$name." nicht vorhanden.");
50 
51   // Datenbankverbindung besteht, aktuellen Datenbanknamen speichern
52   else $dbaktiv = $name;
53  }
54 
55  // ---------------------------
56  // hier die Funktion die die SQL-Abfragen bearbeitet
57  function abfrage( $befehl) {
58 
59   // wieder per global $dbaktiv einbinden
60   global $dbaktiv;
61 
62   // ist der in $dbname gespeicherte Datenbankname nicht der aktuelle? dannFunktion connect_db() aurufen
63   if($this->dbname!=$dbaktiv) $this->connect_db( $this->dbname);
64 
65   // Aufruf der PHP-Funktion mysql_query() um den SQL Befehl abzuarbeiten und die Resourcen-Kennung zurück geben
66 
67   return mysql_query( $befehl);
68  }
69 // ---------------------------
70 }
71 ?>
72 


Um die Daten aus einer Datenbankanfrage auch wirklich verwenden zu können brauchen wir noch eine Funktion die unsere Resourcen-Kennung in ein "Daten-Array" umwandelt.


 1 
 2 <?php
 3 // hier die Variable in der wir speichern ob wir schon eine 
 4 // Datenbankserververbindung haben, gleichzeitig nutzen wir diese als 
 5 // Verbindungskennung um unsere Datenbanken anzusprechen
 6 $verbindung = NULL;
 7 $dbaktiv = '';
 8 
 9 class datenbank {
10 
11  // Datenbankhost
12  var $host = 'localhost';
13 
14  // Datenbankbenutzername
15  var $user = 'admin';
16 
17  // Datenbankpasswort
18  var $passwort = 'projekt';
19 
20  // Datenbankname speichern
21  var $dbname = '';
22 
23  function datenbank( $name) {
24   // diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
25 
26   // Variable $verbindung mit global einbinden
27   global $verbindung;
28 
29   // Datenbankname in $dbname speichern
30   $this->dbname = $name;
31  
32   // abfragen ob Verbindung zum Server bereits besteht, wenn nicht 
33 // Verbindung herstellen
34   if(!$verbindung) $verbindung = @mysql_connect( $this->host, $this->user, $this->passwort);
35  
36   // haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
37   if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
38 
39  }
40 
41  // hier die Funktion die eine Verbindung zu einer Datenbank herstellt
42  function connect_db( $name) {
43   // Variable $verbindung und $dbaktiv einbinden
44   global $verbindung, $dbaktiv;
45 
46   // Datenbank $name Verbindung herstellen
47   $result = @mysql_select_db( $name, $verbindung);
48 
49   // haben wir Datenbankverbindung? wenn nein Fehlermeldung
50   if(!$result) die("Datenbank ".$name." nicht vorhanden.");
51 
52   // Datenbankverbindung besteht, aktuellen Datenbanknamen speichern
53   else $dbaktiv = $name;
54  }
55 
56  // ---------------------------
57  // hier die Funktion die die SQL-Abfragen bearbeitet
58  function abfrage( $befehl) {
59 
60   // wieder per global $dbaktiv einbinden
61   global $dbaktiv;
62 
63   // ist der in $dbname gespeicherte Datenbankname nicht der aktuelle? dannFunktion connect_db() aurufen
64   if($this->dbname!=$dbaktiv) $this->connect_db( $this->dbname);
65 
66   // Aufruf der PHP-Funktion mysql_query() um den SQL Befehl abzuarbeiten und die Resourcen-Kennung zurück geben
67 
68   return mysql_query( $befehl);
69  }
70  // --------------------------
71 // hier unsere Funktion mit der wir unsere Daten aus einer 
72 // Datenbankanfrage zurück geliefert bekommen( hat eigentlich mit der 
73 // Funktionsweise in diesem Tutorial nichts zu tun, diese Funktion 
74 // könnte genauso gut auch außerhalb der Klasse definiert sein)
75 
76  function lade_satz( $id) {
77   return mysql_fetch_array($id);
78  }
79  // --------------------------
80 }
81 ?>
82 


Jetzt haben wir es fast geschafft. Und jetzt werden wir auch erfahren, warum mit diesem Tutorial eigentlich jeder die Wirkungsweise und Vorteile von OOP verstehen sollte.

Wir müssen die Klassendatei in einer normalen PHP-Datei einbinden (require) und die Datenbank-Instanzen erzeugen. Wir nehmen mal an wir haben 3 verschiedene Datenbanken (user, admin, nachrichten) und wollen im Programm selber ohne viel Auwand zwischen diesen Datenbanken hin und her springen.


 1 
 2 <?php
 3 // Klasse einbinden
 4 require("class_datenbank.php");
 5 
 6 // Instanzen erzeugen
 7 $user = new datenbank("user");
 8 $admin = new datenbank("admin");
 9 $nachrichten = new datenbank("nachrichten");
10 
11 // um jetzt eine Datenbank anzusprechen brauchen wir diese nur mit 
12 // dem "Zeiger" ( der den gleichen Namen hat wie die Datenbank aus 
13 // der wir die Daten haben wollen) ansprechen und uns um nichts weiteres zu kümmern
14 
15 // SQL-Anweisung in Datenbank admin ausführen
16 $result = $admin->abfrage("SELECT * FROM admin WHERE <bedingungen>");
17 
18 // Daten holen
19 while($row=$db->lade_satz($result)) {
20  << weitere Anweisungen >>
21 }
22 
23 // SQL Anweisung in $atenbank nachrichten ausführen
24 $nachrichten->abfrage("INSERT INTO nachrichten  << Anweisungen >>");
25 
26 ?>
27 


wenn Sie also Daten aus der Datenbank user haben wollen müssen Sie die Abfrage mit dem zeiger $user durchführen

für die Datenbank admin mit dem Zeiger $admin

für die Datenbank nachrichten mit dem Zeiger $nachrichten

Aber wie funktioniert das?
da wir bei jeder Instanzierung ($admin = new datenbank("admin")) einen anderen Datenbanknamen (in der Variable $dbname) angegeben haben, merken diese 3 Instanzen die ihnen zugewiesenen Datenbanknamen, aus Sicht der Instanz $user heißt die Datenbank user ( gespeichert in $dbname), aus Sicht der Instanz $admin gibt es nur die Datenbank admin und aus Sicht der Instanz $nachrichten nur die Datenbank nachrichten. man könnte auch sagen, die Datenbanknamen sind aus Sicht der Instanzen relativ. oder noch anders, aus Sicht der Instanz $user hat $dbname einen anderen Inhalt als aus der Sicht der Instanz $admin oder $nachrichten.

Viel Spaß mit diesem Tutorial, der wie ich glaube die Wirkungsweise von OOP sehr gut erklärt.

ich bitte um Feedback