Dieses Tutorial beschreibt sehr gut die Wirkunsweise von objektorientiertes Programmieren. Also bestens geeignet um das objektorientierte Programmieren zu verstehen.
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
3class datenbank {
4 5// Datenbankhost
6var $host = 'localhost';
7 8// Datenbankbenutzername
9var $user = 'admin';
10 11// Datenbankpasswort
12var $passwort = 'projekt';
13 14// Datenbankname speichern
15var $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 10class datenbank {
11 12// Datenbankhost
13var $host = 'localhost';
14 15// Datenbankbenutzername
16var $user = 'admin';
17 18// Datenbankpasswort
19var $passwort = 'projekt';
20 21// Datenbankname speichern
22var $dbname = '';
23 24 function datenbank( $name) {
25// diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
26 27 // ------------------------
28 // Variable $verbindung mit global einbinden
29global $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
38if(!$verbindung) $verbindung = @mysql_connect( $this->host, $this->user, $this->passwort);
39 40// haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
41if(!$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 12class datenbank {
13 14// Datenbankhost
15var $host = 'localhost';
16 17// Datenbankbenutzername
18var $user = 'admin';
19 20// Datenbankpasswort
21var $passwort = 'projekt';
22 23// Datenbankname speichern
24var $dbname = '';
25 26 function datenbank( $name) {
27// diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
28 29 // Variable $isverbindung mit global einbinden
30global $verbindung;
31 32// Datenbankname in $dbname speichern
33$this->dbname = $name;
34 35// abfragen ob Verbindung zum Server bereits besteht, wenn nicht Verbindung herstellen
36if(!$verbindung) $verbindung = @mysql_connect( $this->host, $this->user, $this->passwort);
37 38// haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
39if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
40 41 }
42 43// -----------------------------
44 // hier die Funktion die eine Verbindung zu einer Datenbank herstellt
45function connect_db( $name) {
46 47// Variable $verbindung und $dbaktiv einbinden
48global $verbindung, $dbaktiv;
49 50// Datenbank $name Verbindung herstellen
51$result = @mysql_select_db( $name, $verbindung);
52 53// haben wir Datenbankverbindung? wenn nein Fehlermeldung
54if(!$result) die("Datenbank ".$name." nicht vorhanden.");
55 56// Datenbankverbindung besteht, aktuellen Datenbanknamen in $dbaktiv speichern
57else $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
12var $host = 'localhost';
13 14// Datenbankbenutzername
15var $user = 'admin';
16 17// Datenbankpasswort
18var $passwort = 'projekt';
19 20// Datenbankname speichern
21var $dbname = '';
22 23 function datenbank( $name) {
24// diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
25 26 // Variable $verbindung mit global einbinden
27global $verbindung;
28 29// Datenbankname in $dbname speichern
30$this->dbname = $name;
31 32// abfragen ob Verbindung zum Server bereits besteht, wenn nicht Verbindung herstellen
33if(!$verbindung) $verbindung = @mysql_connect( $this->host, $this->user, $this->passwort);
34 35// haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
36if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
37 38 }
39 40// hier die Funktion die eine Verbindung zu einer Datenbank herstellt
41function connect_db( $name) {
42// Variable $verbindung und $dbaktiv einbinden
43global $verbindung, $dbaktiv;
44 45// Datenbank $name Verbindung herstellen
46$result = @mysql_select_db( $name, $verbindung);
47 48// haben wir Datenbankverbindung? wenn nein Fehlermeldung
49if(!$result) die("Datenbank ".$name." nicht vorhanden.");
50 51// Datenbankverbindung besteht, aktuellen Datenbanknamen speichern
52else $dbaktiv = $name;
53 }
54 55// ---------------------------
56 // hier die Funktion die die SQL-Abfragen bearbeitet
57function abfrage( $befehl) {
58 59// wieder per global $dbaktiv einbinden
60global $dbaktiv;
61 62// ist der in $dbname gespeicherte Datenbankname nicht der aktuelle? dannFunktion connect_db() aurufen
63if($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 67return 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
12var $host = 'localhost';
13 14// Datenbankbenutzername
15var $user = 'admin';
16 17// Datenbankpasswort
18var $passwort = 'projekt';
19 20// Datenbankname speichern
21var $dbname = '';
22 23 function datenbank( $name) {
24// diese Funktion wird nur beim Initialiseren der Klasse aufgerufen
25 26 // Variable $verbindung mit global einbinden
27global $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
34if(!$verbindung) $verbindung = @mysql_connect( $this->host, $this->user, $this->passwort);
35 36// haben wir Verbindung zum Datenbankserver? wenn nein Fehlermeldung
37if(!$verbindung) die("Keine Verbindung zum Datenbankserver");
38 39 }
40 41// hier die Funktion die eine Verbindung zu einer Datenbank herstellt
42function connect_db( $name) {
43// Variable $verbindung und $dbaktiv einbinden
44global $verbindung, $dbaktiv;
45 46// Datenbank $name Verbindung herstellen
47$result = @mysql_select_db( $name, $verbindung);
48 49// haben wir Datenbankverbindung? wenn nein Fehlermeldung
50if(!$result) die("Datenbank ".$name." nicht vorhanden.");
51 52// Datenbankverbindung besteht, aktuellen Datenbanknamen speichern
53else $dbaktiv = $name;
54 }
55 56// ---------------------------
57 // hier die Funktion die die SQL-Abfragen bearbeitet
58function abfrage( $befehl) {
59 60// wieder per global $dbaktiv einbinden
61global $dbaktiv;
62 63// ist der in $dbname gespeicherte Datenbankname nicht der aktuelle? dannFunktion connect_db() aurufen
64if($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 68return 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 76function 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
4require("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
19while($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.
Die Todesstern-Projekte sind spektakulär gescheitert. Lernen Sie von den Fehlern des Imperiums und bewahren Sie Ihre Projekte davor, der dunklen Seite der Macht zu verfallen!
Im Forum suchen
|07.12.2010 | 
42807 | KAT : 
Deutsch 
