So kapseln Sie Datenbankoperationen in PHP

Kapselung von Datenbankoperationen in PHP

Viele Aspekte des dynamischen Webdesigns umfassen Datenbankoperationen, aber manchmal erfordert der Wechsel zu anderen Backend-Datenbanken bei Bedarf eine große Anzahl von Programmänderungen. Dies ist eine mühsame, zeitaufwändige und fehleranfällige Aufgabe. Tatsächlich können wir Klassen in PHP verwenden, um Datenbankoperationen zu kapseln, sodass das geschriebene Programm Änderungen an der Hintergrunddatenbank mit sehr kleinen Änderungen abschließen kann.
Jetzt kapseln wir es in dbfz.inc und sein Design ist wie folgt:

class dbInterface{ var $dbID=1; //Wird verwendet, um die Datenbank für den aktuellen Vorgang zu bestimmen. Wenn dbID 1 ist, repräsentiert es MySQL, wenn es 2 ist, repräsentiert es SQL Server, und wenn es 3 ist, repräsentiert es ODBC oder andere.
var $dbHost; //Der Domänenname des Hosts, auf dem sich die Datenbank befindet
var $dbUsername; //Datenbankbenutzername
var $dbPassWord; //Benutzerpasswort
//Host-, Benutzernamen- und Passwortfunktionen festlegen
Funktion setParameter($host,$username,$password){
$this->dbUsername=$username; $this->dbHost=$host; $this->dbPassword=$password;
} //Datenbankfunktion beitreten
Funktion dbConnect(){
switch($this->dbID)
{
Fall 1;
return @mysql_connect($this->dbHost,$this->dbUsername,$this->dbPassword); Fall 2;
//Funktionen verwenden, die SQL Server
unterstützen Fall 3;
//Funktionen verwenden, die ODBC
unterstützen }
}
//Schließe die Bibliotheksfunktion
Funktion dbClose($dataHandle){
switch($this->dbID)
{
Fall 1;
mysql_close($dataHandle);
Fall 2;
//Funktionen verwenden, die SQL Server
unterstützen Fall 3;
//Funktionen verwenden, die ODBC
unterstützen }
}

//SQL-Anweisungsfunktion
ausführen Funktion dbQuery($dbName,$sql,$dbHandle){
switch($this->dbID)
{
Fall 1;
return @mysql_db_query($dbName,$sql,$dbHandle); Fall 2;
//Funktionen verwenden, die SQL Server
unterstützen Fall 3;
//Funktionen verwenden, die ODBC
unterstützen }
}

//Rufen Sie die aktuelle Datensatzfunktion des SQL-Rückgabewerts
ab Funktion dbFetchrow($dataHandle,$offset=-1){
switch($this->dbID)
{
Fall 1;
@mysql_data_seek($dataHandle,$offset);
return @mysql_fetch_row($dataHandle);
Fall 2;
//Funktionen verwenden, die SQL Server
unterstützen Fall 3;
//Funktionen verwenden, die ODBC
unterstützen }
}

//Funktion „Abgerufene Datensatznummer“ zurückgeben
Funktion dbNumrows($dataHandle){
switch($this->dbID)
{
Fall 1;
return @mysql_num_rows($dataHandle);
Fall 2;
//Funktionen verwenden, die SQL Server
unterstützen Fall 3;
//Funktionen verwenden, die ODBC
unterstützen }
}

//Die Funktion zum Abrufen der Anzahl der Spalten zurückgeben
Funktion dbNumcols($dataHandle){
switch($this->dbID)
{
Fall 1;
return @mysql_num_fields($dataHandle);
Fall 2;
//Funktionen verwenden, die SQL Server
unterstützen Fall 3;
//Funktionen verwenden, die ODBC
unterstützen }
}
}

Hier ist die Gebrauchsanweisung:

Verwenden Sie die dbInterface-Klasse, um ein Objekt im Programm $test=new dbInterface; zu generieren
Parameter einstellen
test->$dbUsername ;Benutzername
test->$dbPassword; Passwort
test->$dbHost;Host
void setParameter(string host, string username, string passwort);
Datenbankverbindung: dbhandle test->dbConnect();
Rückgabewert: Fasle, Datenbankverbindungsfehler
>0, Datenbankverbindungshandle

Datenbank schließen: void test->dbClose(dbhandle);

Tabellenoperation: int test->dbQuery(string Datenbankname, string sql, dbhandle); SQL-Anweisung
ausführen
Rückgabewert: false, SQL-Ausführungsfehler
>0, SQL wird korrekt ausgeführt und zeigt auf den SQL-Rückgabewert

Datenoperation: int test->dbFetchrow(dataHandle, int offset); ruft den aktuellen Datensatz des SQL-Rückgabewerts ab. Nach erfolgreicher Ausführung bewegt sich der Zeiger zum nächsten Datensatz
int test->dbNumrows(dataHandle); Ermittelt die Anzahl der nach der SQL-Ausführung erhaltenen Datensätze (hauptsächlich SELECT-Anweisung)
int test->dbNumcols(dataHandle); Ruft die Anzahl der Datensatzfelder ab, die nach der SQL-Ausführung erhalten wurden (hauptsächlich SELECT-Anweisung)

Zur Erläuterung geben wir Ihnen nun ein Beispiel:

Die Datenbank verwendet MQSQL: Ihr Hostname ist „localhost“, der Benutzername ist „root“ und das Passwort ist „“.
Es gibt eine testdb-Datenbank und Tabelle1 in MySQL. Die Tabelle enthält zwei Felder: Name und Bezahlung

-----

require("testdb.inc"); //dbInterface-Klasse laden
$test = new dbInterface;//Erzeuge ein Objekt mit der Klasse dbInterface
$test->setParameter("localhost","root",""); //Datenbankparameter festlegen
$db = $test->dbConnect();//Mit der Datenbank verbinden
$Query = "SELECT name,pay FROM table ";//SQL-Anweisung festlegen
$temp_result = $test->dbQuery("testdb",$Query,$db); //Datenmaster-Datenbankoperation ausführen
echo "
"; $ls_num = $test->dbNumrows($temp_result); //Anzahl der Datensätze im Abfrageergebnis abrufen
echo $ls_num;
echo "
"; if (ls_num>0 )
{
$ls_col = $test->dbNumcols($db); //Ermitteln Sie die Anzahl der Spalten in der Tabelle
echo $ls_col;
echo "
"; $cate_result=$test->dbFetchrow($temp_result,0);//Erste Zeile der Datensatznummer
abrufen $hcid=$cate_result[0];//Den Wert des Namens
abrufen $hcate=$cate_result[1];//Erhalten Sie den Wert der Bezahlung
echo $hcid;
echo "
"; echo $hcate;
}

?>

---

Dies ist eine einfache anwendungsgekapselte Klasse, um den Betrieb der Datenbank abzuschließen. Wenn Sie andere Datenbanken betreiben möchten, müssen Sie nur die dbID-Variable in der dbInterface-Klasse ändern.


Das Obige stellt vor, wie man Datenbankoperationen in PHP kapselt, einschließlich verschiedener Aspekte. Ich hoffe, es wird für Freunde hilfreich sein, die sich für PHP-Tutorials interessieren.