Deutsch
Deutsch
Bei der Entwicklung von PHP -Anwendungen sind MySQLI -Erweiterungen eine häufige Möglichkeit, mit MySQL -Datenbanken zu interagieren. Wenn das Projekt weiter erweitert wird, kann die Verwendung von MySQLI -Funktionen direkt zu einer Duplikation des Codes, einer hohen Kopplung und der schwer zu verwaltenden. Um die Wiederverwendbarkeit und Wartbarkeit der Code zu verbessern, können wir die Funktion mySQLI_Result in eine gemeinsame Datenzugriffsschicht einschließen.
In diesem Artikel wird vorgestellt, wie Sie die Funktion mySQLI_Result incapsuliert und Codebeispiele bereitstellen, mit denen Sie eine effiziente und leicht zu kontrollierende Datenzugriffsschicht erstellen können.
Der Zweck der Datenzugriffsschicht besteht darin, Datenbankvorgänge von der Geschäftslogik zu trennen, damit die Zugriffslogik der Datenbank nicht direkt in der Geschäftsordnung der Anwendung angezeigt wird. Durch die Einkapselung der Datenbankvorgänge kann die Wiederverwendbarkeit und Wartbarkeit des Codes verbessert werden, und die Schwierigkeit, die Datenbank in der späteren Phase zu ersetzen, kann reduziert werden.
Hier sind einige Punkte zu berücksichtigen, um eine Datenzugriffsschicht zu entwerfen:
Verknüpfung von Datenbankverbindungen : Vermeiden Sie das wiederholte Schreiben von Verbindungscode jedes Mal, wenn Sie die Datenbank betreiben.
Vereinfachen Sie die Abfrageergebnisverarbeitung : Kapitulieren Sie den Betrieb von MySQLI_Result und Prozessabfrage auf einheitliche Weise.
Unterstützung von CRUD -Operationen : Unterstützen Sie gemeinsame Ergänzung, Löschung, Änderung und Überprüfungsvorgänge.
Verbesserung der Code -Wiederverwendbarkeit : Durch die Kapselung ist die Wiederverwendbarkeit des Datenbankoperationscode höher und die Code -Redundanz reduziert.
Zunächst müssen wir eine Datenbankklasse erstellen, um die Verbindungs- und Abfragebetriebe der Datenbank zu verwalten.
class Database {
private $connection;
// Konstruktor initialisiert die Datenbankverbindung
public function __construct($host, $user, $password, $dbname) {
$this->connection = new mysqli($host, $user, $password, $dbname);
if ($this->connection->connect_error) {
die("Verbindung ist fehlgeschlagen: " . $this->connection->connect_error);
}
}
// Eine Frage ausführen，Rückgabeergebnissatz
public function query($sql) {
$result = $this->connection->query($sql);
if (!$result) {
die("Abfrage fehlgeschlagen: " . $this->connection->error);
}
return $result;
}
// Schließen Sie die Datenbankverbindung
public function close() {
$this->connection->close();
}
}
Im obigen Code umfassen wir eine Datenbankklasse mit einem Konstruktor zur Initialisierung der Datenbankverbindung und eine Abfragethode zum Ausführen von SQL -Abfragen und zur Rückgabe des Ergebnissatzes.
MySQLI_Result ist ein Objekt in MySQLI , mit dem die Ergebnisse von Abfragen gelagert werden. Wenn wir die Datenzugriffsschicht erstellen, müssen wir normalerweise mySQLI_Result zusammenfassen, um den Betrieb des Ergebniss präziser zu gestalten.
Hier ist ein Codebeispiel, wie MySQLi_Result in Zusammenhang steht:
class DbResult {
private $result;
// Der Konstruktor erhält Abfrageergebnisse
public function __construct($result) {
$this->result = $result;
}
// Holen Sie sich alle Ergebnisse
public function fetchAll() {
$rows = [];
while ($row = $this->result->fetch_assoc()) {
$rows[] = $row;
}
return $rows;
}
// Erhalten Sie Einzelzeilenergebnisse
public function fetchOne() {
return $this->result->fetch_assoc();
}
// Holen Sie sich die Anzahl der Zeilen
public function numRows() {
return $this->result->num_rows;
}
}
Im obigen Code verkauft die DBRESULT -Klasse das Objekt mySQLI_Result und enthält die folgenden Methoden:
Fetchall () : Holen Sie sich alle Abfragergebnisse.
Fetchone () : Erhalten Sie das Ergebnis einer einzelnen Abfrage.
Numrows () : Gibt die Anzahl der Zeilen im Abfrageergebnis zurück.
Durch Kombination der Datenbankklasse und der Ergebniskapselungsklasse der Ergebnismenge können wir eine vollständige Datenzugriffsschicht erstellen, wie unten gezeigt:
class DataAccessLayer {
private $db;
// Konstruktor initialisiert die Datenbankverbindung
public function __construct($host, $user, $password, $dbname) {
$this->db = new Database($host, $user, $password, $dbname);
}
// Fragen Sie die Daten ab und geben Sie den eingekapselten Ergebnissatz zurück
public function fetchData($sql) {
$result = $this->db->query($sql);
$dbResult = new DbResult($result);
return $dbResult;
}
// Daten einfügen
public function insertData($sql) {
return $this->db->query($sql);
}
// Daten aktualisieren
public function updateData($sql) {
return $this->db->query($sql);
}
// Daten löschen
public function deleteData($sql) {
return $this->db->query($sql);
}
// Schließen Sie die Verbindung
public function close() {
$this->db->close();
}
}
In diesem Beispiel verkauft die DataAccessLayer -Klasse gemeinsame Datenbankvorgänge wie Abfrage, Einfügen, Aktualisieren und Löschen. Wir verwenden die DBRESULT -Klasse, um die Abfrageergebnisse zu verkapulieren, wodurch der Betrieb der Ergebnisse bequemer wird.
Jetzt können wir die eingekapselte Datenzugriffsschicht in unserer Geschäftsordnung verwenden:
// Erstellen Sie ein Datenbankzugriffsobjekt
$dal = new DataAccessLayer('localhost', 'root', '', 'test_db');
// Abfragedaten
$sql = "SELECT * FROM users";
$dbResult = $dal->fetchData($sql);
// Abfragenergebnisse erhalten
$users = $dbResult->fetchAll();
foreach ($users as $user) {
echo $user['username'] . "<br>";
}
// Schließen Sie die Datenbankverbindung
$dal->close();
Auf diese Weise können wir Datenbankvorgänge problemlos ausführen, ohne wiederholt Logik wie Verbindungen, Abfragenergebnisse usw. auf jeder Seite zu schreiben.
Durch die Einkapselung der Ergebnis -Set und der Datenbankverbindung von MySQLI_Result erstellen wir eine gemeinsame Datenzugriffsschicht. Diese Datenzugriffsschicht macht Datenbankvorgänge prägnanter, wiederverwendbarer und verbessert die Wartbarkeit des Codes. Sie können diese Datenzugriffsschicht entsprechend Ihren Geschäftsanforderungen weiter erweitern und mehr Datenbankoperationen wie Transaktionsmanagement, Stapelinsertion usw. unterstützen.
Wenn Sie Datenbankverbindungen flexibler verwalten möchten, können Sie ein Singleton -Muster einführen, um das Erstellen von Datenbankverbindungen mehrmals zu vermeiden.
Ich hoffe, dieser Artikel kann Ihnen helfen, eine effizientere und wartbarere Datenbankbetriebsebene aufzubauen und Ihre Entwicklungseffizienz zu verbessern.
