Um mit PHP eine Verbindung zu einer mySQL-Datenbank herzustellen, benötigt man unter anderem die mysql_connect()-Funktion von PHP.
Dabei wird es auf Dauer etwas mühselig, immer wieder auf´s Neue alle benötigten Funktionen einzubringen. Aus diesem Grund bietet es sich an, für den Zugriff auf eine Datenbank eine eigene objektorientierte Klasse zu programmieren, die einfach in jedes neue Projekt eingebunden wird (includiert oder required).
Für mein eigenes kleines CMS hatte ich vor längerer Zeit mal eine Klasse geschrieben, die nach Instanziierung eines Objektes folgendes ermöglicht:
- Verbindung zur mySQL-Datenbank herstellen
- Auswahl einer Datenbank/ Tabelle
- Senden einer SQL-Anfrage
- Daten holen (in einem Array)
- Anzahl Datensätze anzeigen
(z.B. zur Überprüfung).
Schritt für Schritt von oben nach unten:
<?php
//dbconnect.class.php
class DBconnect //Klassenname
{
private $ers; //Hilfs-Variable
...
Zunächst kommt nach dem einleitenden PHP-Tag der spätere Name der Datei. Dieser wird auskommentiert und ist nicht zwingend notwendig, sollte ordnungshalber aber aufgeführt werden (Name, Erstellungsdatum … lasse ich mal außen vor).
Die Klasse bekommt nun ihren Namen, den ich am Anfang groß schreibe (genau wie in Java …) und wird durch das Schlüsselwort public für den öffentlichen Zugriff freigegeben. Die folgende Variable $ers dient innerhalb der Klasse als Helferlein und ist durch das Schlüsselwort privat nur innerhalb der Klasse verfügbar (kann nicht von außen angesprochen werden).
Darauf folgt der Konstruktor:
... public function __construct($datenbank,$host="127.0.0.1", $benutzer="root",$passwd="passwort") { /* mysql_connect — ÖFFNET eine VERBINDUNG zu einem MySQL- Server und gibt eine Meldung aus, falls ein SQL-Fehler erfolgt */ $db_link = mysql_connect($host,$benutzer,$passwd,TRUE) or die (mysql_error()); /* ------------------------------------------------------------ Anmerkung: Anstatt das Script über '... or die(...)' einfach abzubrechen, kann auch eine Fehlermeldung wie folgt ausgegeben werden. if(!$db_link) { trigger_error("Es konnte keine Verbindung zur Datenbank hergestellt werden.", E_USER_ERROR); } ------------------------------------------------------------- */ /* mysql_select_db — AUSWAHL einer MySQL DATENBANK */ mysql_select_db($datenbank) or die("Konnte die Datenbank nicht waehlen."); } ...
Der Konstruktor wird automatisch bei Erzeugung/ Instanziierung eines Objektes der Klasse DBconnect aufgerufen und erwartet Parameter (Datenbankname, Host, Benutzername und Passwort).
Wird stets nur auf eine Datenbank zugegriffen, dann kann den Parametern direkt in der Klasse ein Wert zugewiesen werden. Die Zuweisung erfolgt aber nur dann, wenn kein Wert für den jeweiligen Parameter übergeben wird.
In unserem Beispiel müßte für die Verbindung zur Datenbank lediglich der Name der Tabelle bei der Objekterzeugung mit übergeben werden. Die restlichen Informationen werden der Zuweisung (rot dargestellt) entnommen. Übergibt man aber nicht nur den Name der Tabelle, sondern zum Beispiel ein anderes Passwort (…), dann müssen alle Parameter in der richtigen Reihenfolge von links nach rechts übergeben werden (und die vordefinierten zählen dann nicht). Das bedeutet, dass zusätzlich zum Passwort auch der Benutzername übergeben werden muss, da dieser vor dem Passwort in der Parameterübergabe liegt.
Dies soll nur der Vollständigkeit halber verdeutlichen, dass einem Parameter so wie oben auch ein fester Wert zugewiesen werden kann.
Würde jetzt der Tabellenname ebenfalls einen festen Wert erhalten, dann bräuchte man überhaupt keinen Parameter übergeben (vorausgesetzt, die Werte stimmen mit denen der anzusprechenden Datenbank überein).
Ich merke, dass ich schon wieder viel zu viel schreibe und abdrifte, daher bremse ich hier etwas ab!
Durch den so definierten Konstruktor könnte nun im jeweiligen Script, wo unsere Klasse eingebunden wurde, schon ein Objekt erzeugt werden:
$datenbankverbindung = DBconnect('tabellenname');
// oder bei einer anderen Datenbank
$datenbankverbindung = DBconnect('tabellenname','127.0.0.1','willi','geheim');
Dadurch wird aber erst die Verbindung hergestellt.
Kommen wir nun weiter zu den Funktionen (auch Methoden genannt), durch die nun mit der Datenbank kommuniziert werden kann, nachdem die Verbindung aufgebaut wurde.
function sql($sql_query)
{
return $this->ers = mysql_query($sql_query)
or die ('Anfrage fehlgeschlagen');
/*mysql_query — SENDET eine ANFRAGE an MySQL*/
}
function data()
{
return mysql_fetch_row($this->ers);
/*mysql_fetch_row — LIEFERT einen DATENSATZ
als indiziertes ARRAY*/
}
function anzahl()
{
return mysql_num_rows($this->ers);
/*mysql_num_rows — LIEFERT die ANZAHL der
DATENSÄTZE*/
}
function __destruct()
{
mysql_close();
/*mysql_close — SCHLIEßT die VERBINDUNG zur Datenbank*/
}
Die erste Funktion sql ermöglich es, durch die PHP-Funktion mysql_query(’string’) ein SQL-Statement an die Datenbank zu stellen (SELECT, UPDATE, DELETE, …).
Bei den weiteren Funktionen sollte klar sein, was sie bewirken. Wobei die __destruct-Funktion eigentlich nicht nötig ist, da nach Beendigung des jeweiligen Scriptes die Verbindung sowieso getrennt wird. Jedoch kann es vorkommen, dass mehrere Verbindungen hergestellt werden sollen …!
Was hat man nun gewonnen? Dazu sehen Sie sich bitte folgende Beispiele an.
Ohne DBconnect-Klasse
$db_link = mysql_connect($host,$benutzer,$passwd,TRUE)
or die (mysql_error());
mysql_select_db('tabellenname')
or die("Konnte die Datenbank nicht waehlen.");
$sql_query = 'SELECT * FROM datenbank';
$ressource = mysql_query($sql_query)
or die ('Anfrage fehlgeschlagen');
$anzahl = mysql_num_rows($ressource);
if($anzahl > 0){
while ($data = mysql_fetch_array($ressource)){
...
}
}
Mit DBconnect-Klasse:
$dbconnect = new DBconnect("tabellenname");
$sql_query = 'SELECT * FROM datenbank';
$dbconnect->sql($sql_query);
if($dbconnect->anzahl() > 0){
while($data=$dbconnect->data()){
...
}
}
Sehr viel kürzer und übersichtlicher, oder?! Man beachte im Beispiel ohne DBconnect-Klasse die Variable $ressource. Die Übergabe dieses Wertes erfolgt bei uns schon in der Klasse selber. Sie haben es bestimmt erkannt, dafür wurde unsere Variable $ers … unser Helferlein eingesetzt.
Der Quellcode steht zur freien Verfügung!
(Hier noch mal der gesamte Quellcode)
------------------------------------------------------------------------------------------------------------------------
<?php
//dbconnect.class.php
class DBconnect
{
private $ers;
/*Konstruktor ... wird automatisch bei Erzeugung/ Instanziierung eines Objektes der Klasse
aufgerufen und erwartet Parameter (Datenbankname, Host, Benutzername, Passwort)*/
public function __construct($datenbank,$host="127.0.0.1",$benutzer="root",$passwd="passwort")
{
/*mysql_connect — ÖFFNET eine VERBINDUNG zu einem MySQL-Server und
gibt eine Meldung aus, falls ein SQL-Fehler erfolgt*/
$db_link = mysql_connect($host,$benutzer,$passwd,TRUE) or die (mysql_error());
/*mysql_select_db — AUSWAHL einer MySQL DATENBANK*/
mysql_select_db($datenbank) or die("Konnte die Datenbank nicht waehlen.");
/*if(!$db_link) echo "Fehler DB-Verbindung";*/
}
function sql($sql_query)
{
return $this->ers = mysql_query($sql_query) or die ('Anfrage fehlgeschlagen');
/*mysql_query — SENDET eine ANFRAGE an MySQL*/
}
function data()
{
return mysql_fetch_row($this->ers);
/*mysql_fetch_row — LIEFERT einen DATENSATZ als indiziertes ARRAY*/
}
function anzahl()
{
return mysql_num_rows($this->ers);
/*mysql_num_rows — LIEFERT die ANZAHL der DATENSÄTZE*/
}
function __destruct()
{
mysql_close();
/*mysql_close — SCHLIEßT die VERBINDUNG zur Datenbank*/
}
}
?>
Diesen einfach in einen Editor ihrer Wahl kopieren und zum Beispiel als dbconnect.class.php speichern. In ein neues Projekt wird die Klasse direkt oben per include oder require eingebunden:
include("class/dbconnect.class.php");
// oder
require("class/dbconnect.class.php");
// oder
require_once("class/dbconnect.class.php");
Ich hoffe, ich konnte dem einen oder anderen die Vorteile einer Datenbank-Klasse näherbringen.
(3 votes, average: 4,67 out of 5)
Loading ...