9. Jan 2023
Lesedauer 10 Min.
Mit Datenbanken arbeiten
PHP-Frameworks optimal einsetzen (Teil 4)
PHP-Applikationen greifen häufig auf Datenbanken zu. Das Framework Yii bietet dafür umfassende Unterstützung, beginnend bei der Anbindung der Datenbanken, über eine Repräsentation der Daten bis zur Darstellung auf der Benutzeroberfläche.
Im letzten Teil dieser Artikelserie haben wir die Arbeit mit Datenbanken für Applikationen, welche auf der Basis des Yii-Frameworks in PHP entwickelt werden, betrachtet. Um Daten aus einer Datenbank in einer PHP-Anwendung zu verarbeiten, müssen wir die folgenden Aufgaben bewältigen: Verbindung zur Datenbank herstellen, Datenstruktur entsprechend der Datenbankstruktur im Quelltext definieren, Abfrage der Daten und Anzeige der Daten auf der Oberfläche.Die Daten können in den unterschiedlichsten Datenbanken gespeichert werden. Oft sind es relationale Datenbanken, wie MySQL oder MSSQL, aber auch zunehmend NoSQL-Datenbanken, wie MongoDB. Damit man sich nicht mit den unterschiedlichen Datenbanktreibern herumschlagen muss, kommt meist eine generische Datenbankschnittstelle wie PDO zum Einsatz, über welche der Zugriff auf die Datenbank hergestellt wird. Damit hat man eine allgemein zu verwendende Datenbankschnittstelle – unabhängig von der tatsächlich zum Einsatz kommenden Datenbank. Auf diese Weise kann man zu einem späteren Zeitpunkt die Datenbank auch bei Bedarf austauschen (Datenbankmigration).Die Daten müssen im Programm in einer entsprechenden Datenstruktur abgelegt und mit der Datenbank synchronisiert werden. In relationalen Datenbanken werden die Daten in Tabellenform gespeichert. Im PHP-Programm erfolgt eine Speicherung der Daten in Objekte, welche wiederum zu Klassen zugehörig sind. Diese Transformation der Daten zwischen den Tabellen der Datenbank und der Objekte im Speicher bezeichnet man als objektrelationales Mapping. Im Quellcode des Programms wird die Datenbank dann in Form von Klassen und Objekten abgebildet, was die Programmierung erleichtert. ActiveRecord ist die Schnittstelle im Yii-Framework, welches für das Mapping der Daten sorgt.
So präsentiert sichdie Struktur des Yii-Frameworks(Bild 1)
www.yiiframework.com
Die Abfrage der konkreten Daten beziehungsweise die Manipulation der Daten erfolgt durch die Formulierung von Abfragen auf das ActiveRecord. Dabei werden Statements verwendet, welche vom konkreten Datenbankmanagementsystem (DBMS) unabhängig sind. Die Abfrage der Daten erfolgt gemäß dem Konzept von Yii in einem Controller. Liegen die Daten in den Objekten des Programms (Speicher) vor, müssen diese angezeigt werden. Das erfolgt über entsprechende View-KlassenOrdnen wir die Datenbank in das Konzept der Yii-Anwendung ein. Wir kennen das schon in den letzten Teil der Serie präsentierte Architekturschema einer Yii-Anwendung (Bild 1). Und die Datenbank? Diese scheint in der Darstellung noch zu fehlen. ActiveRecords sind spezielle Model-Klassen und diese stellen die Verbindung zur Datenbank her (Bild 2).
Einordnung der Datenbankin die Architektur der Yii-Anwendung(Bild 2)
Krypczyk
Standardmäßig verwendet PHP die generische Schnittstelle PDO (PHP Data Objects) für den Zugriff auf Datenbanken. Aufbauend auf PDO bietet Yii DAO (Database Access Objects) ein objektorientiertes API für den Zugriff auf die relationalen Datenbanken. Yii DAO ist daher die Basis für die Nutzung der weiteren Funktionen für die Arbeit mit Datenbanken in Programmen, welche das Yii-Framework nutzen. Das Yii-Framework unterstützt die folgenden Datenbanken:Die hier genannten Datenbanken sind alles relationale beziehungsweise objektrelationale Datenbanken. Auch wenn diese Form der Datenbanken weiterhin den größten Teil der Anforderungen für Business-Applikationen abdecken dürften, besteht jedoch zunehmend die Anforderung zur Nutzung von NoSQL-Datenbanken. Wie werden diese Datenbanken vom Yii-Framework unterstützt? In der Dokumentation werden dazu die Datenbanken Redis, MongoDB und ElasticSearch aufgeführt:Damit werden in Yii-basierten Applikationen auch unterschiedliche Arten von NoSQL-Datenbanken unterstützt. In Kombination mit den Standard-Datenbanken (relational) sollten sich alle Anforderungen realisieren lassen.
Unterstützte Datenbanken
Um die genannten relationalen beziehungsweise objektrelationalen Datenbanken in einer Yii-Applikation zu nutzen, müssen Sie nichts weiter machen, da diese Datenbanken direkt unterstützt werden. Es sind lediglich die Verbindungsdaten zu konfigurieren.Für die genannten NoSQL-Datenbanken müssen zusätzlich Extensions installiert und konfiguriert werden. Das liegt daran, dass die relationalen Datenbanken über den generischen PDO-Datenbanktreiber von PHP angesprochen werden. NoSQL-Datenbanken können auf diese Weise nicht adressiert werden. Konkret sieht es wie folgt aus: Für MongoDB ist es notwendig die allgemeine Extension für die Nutzung von MongoDB von der Seite https://www.php.net/manual/en/set.mongodb.php zu installieren. Diese Erweiterung integriert sich direkt in die PHP-Installation. Für Redis gibt es ein Installationspaket über Composer. Möchten Sie die In-Memory-Datenbank Redis nutzen, dann installieren Sie das Paket wie folgt:php composer.phar <span class="hljs-built_in">require</span> <span class="hljs-comment">--prefer-dist yiisoft/yii2-redis</span>
Auch für ElasticSearch steht ebenfalls eine Erweiterung über Composer zur Verfügung. Sie unterstützt ElasticSearch 5.0 und höher. Mittels Composer können Sie die Extension so installieren:
composer <span class="hljs-built_in">require</span> <span class="hljs-comment">--prefer-dist </span>
<span class="hljs-comment">yiisoft/yii2-elasticsearch</span>
Das Ziel ist es, die Datenbank mit den Objekten im Quellcode zu verbinden. Das Vorgehen bezeichnet man allgemein als Object-Relational Mapping (ORM). Hier unterscheiden wir grundsätzlich die beiden Ansätze Code-First und Database-First, um das Ziel zu erreichen. Sehen wir uns diese Ansätze zunächst etwas aus der allgemeinen Perspektive an, bevor wir uns die sich bietenden Optionen im Yii-Framework betrachten.Code-First ist ein sehr beliebter Ansatz unter MVC-Programmierern. Man hat die volle Kontrolle über den Quellcode. Bei diesem Ansatz werden zuerst Entitäten oder Klassen erstellt, wobei der primäre Fokus auf der Domäne einer Anwendung liegt. Sie können mit dem Erstellen von Klassen und erforderlichen Eigenschaften beginnen, ohne die Datenbank zu entwerfen. Dann erstellt man – meist mit Hilfe eines Tools – aus den Datenklassen die Datenbank mit ihren Tabellen. Der Fokus liegt hier also auf den Datenklassen (objektorientiert) und die Datenbank wird erst im zweiten Schritt generiert.
Datenbank mit den Objekten verbinden
Beim Ansatz Database-First werden zuerst die Datenbank und die zugehörigen Tabellen erstellt. Danach können Sie aus der bestehenden Datenbank automatisch mit Hilfe des ORM-Tools die Datenklassen generieren. Diese Vorgehensweise hat den Vorteil, dass es Datenbank- und programmiersprachenunabhängige Tools gibt, um die Datenbank zu entwerfen (konzeptionelles Schema). Aus dem konzeptionellen Schema der Datenbank wird der konkrete SQL-Quellcode für das automatische Generieren der Datenbank erstellt.Welchen Ansatz man wählt, hängt von unterschiedlichen Faktoren ab. Existiert bereits eine Datenbank, dann hat man keine Wahl. Die Datenstruktur ergibt sich aus der vorliegenden Tabellenstruktur. Im Idealfall kann man aus der Datenbank die zugehörigen Datenklassen automatisch generieren. Dieses Vorgehen trifft zum Beispiel immer dann zu, wenn bereits eine Applikation mit der Datenbank existiert und diese gegen eine neue Applikation abgelöst werden soll (Migration).Startet man ein neues Projekt, ohne dass bereits eine Datenbank und auch keine Datenklassen existieren, kann man die Vorgehensweise frei auswählen. Für beide Ansätze gibt es Argumente, welche dafür und dagegen sprechen. Startet man mit der Datenbank, dann kann man beispielsweise mit einem konzeptionellen Modell beginnen.
Die Varianten,wie man eine Datenbank mit den Objekten verbinden kann(Bild 3)
Krypczyk
Das kann man zunächst unabhängig von der konkreten Datenbank machen. Man definiert also ein generisches Modell der Datenbank und überführt dieses in ein konkretes Datenbankschema und gleichzeitig überführt man das Modell in eine objektorientierte Entsprechung im Quellcode. In der Fachwelt wird diese Vorgehensweise als Model-First-Ansatz bezeichnet. Alle Varianten sind konzeptionell in Bild 3 dargestellt.
Datenbank und Yii-Framework verbinden
In diesem Abschnitt durchlaufen wir beispielhaft den Vorgang, eine Datenbank mit dem Quellcode zu verbinden. Starten Sie mit einer Datenbank. Nutzen Sie dazu eine Arbeitsumgebung, bestehend aus XAMPP (Apache Server und MySQL-Datenbank) und einer generierten Beispielapplikation mit dem Yii-Framework. Weitere Informationen finden Sie in den Teilen 2 und 3 der Artikelserie beziehungsweise in der Online-Dokumentation des Yii-Frameworks. Datenbanken können wir direkt im Browser über phpMyAdmin anlegen, administrieren und verwalten. Rufen Sie die Verwaltungsoberfläche von phpMyAdmin auf und erstellen Sie eine neue Datenbank, zum Beispiel mit der Bezeichnung testdb (Bild 4).
Tool für die Administration:Datenbank in phpMyAdmin anlegen(Bild 4)
Krypczyk
Sie benötigen mindestens eine Tabelle und einige wenige Beispieldaten. Das erledigen Sie über einfache SQL-Statements. Erstellen Sie beispielsweise eine Tabelle products mit einigen wenigen Spalten und entsprechenden Datentypen mit den folgenden SQL-Befehl:
<span class="hljs-keyword">CREATE</span> <span class="hljs-keyword">TABLE</span> <span class="hljs-keyword">IF</span> <span class="hljs-keyword">NOT</span> <span class="hljs-keyword">EXISTS</span> products (
productID <span class="hljs-built_in">INT</span> <span class="hljs-keyword">UNSIGNED</span> <span class="hljs-keyword">NOT</span> <span class="hljs-literal">NULL</span> AUTO_INCREMENT,
productCode <span class="hljs-built_in">CHAR</span>(<span class="hljs-number">3</span>) <span class="hljs-keyword">NOT</span> <span class="hljs-literal">NULL</span> <span class="hljs-keyword">DEFAULT</span> <span class="hljs-string">''</span>,
<span class="hljs-keyword">name</span> <span class="hljs-built_in">VARCHAR</span>(<span class="hljs-number">30</span>) <span class="hljs-keyword">NOT</span> <span class="hljs-literal">NULL</span> <span class="hljs-keyword">DEFAULT</span> <span class="hljs-string">''</span>,
quantity <span class="hljs-built_in">INT</span> <span class="hljs-keyword">UNSIGNED</span> <span class="hljs-keyword">NOT</span> <span class="hljs-literal">NULL</span> <span class="hljs-keyword">DEFAULT</span> <span class="hljs-number">0</span>,
price <span class="hljs-built_in">DECIMAL</span>(<span class="hljs-number">7</span>,<span class="hljs-number">2</span>) <span class="hljs-keyword">NOT</span> <span class="hljs-literal">NULL</span> <span class="hljs-keyword">DEFAULT</span> <span class="hljs-number">99999.99</span>,
PRIMARY <span class="hljs-keyword">KEY</span> (productID)
);
Ebenso wird ein Primärschlüssel zur Tabelle (Key) angelegt. Nun brauchen SIe einige Beispieldatensätze. Auch diese fügen SIe mittels SQL-Befehlen hinzu, zum Beispiel so:
<span class="hljs-keyword">INSERT</span> <span class="hljs-keyword">INTO</span> products <span class="hljs-keyword">VALUES</span>
(<span class="hljs-literal">NULL</span>, <span class="hljs-string">'PEN'</span>, <span class="hljs-string">'Pen Blue'</span>, <span class="hljs-number">8000</span>, <span class="hljs-number">1.25</span>),
(<span class="hljs-literal">NULL</span>, <span class="hljs-string">'PEN'</span>, <span class="hljs-string">'Pen Black'</span>, <span class="hljs-number">2000</span>, <span class="hljs-number">1.25</span>);
Ist das erledigt, dann haben Sie für die weitere Porgrammierung eine minimale Datenbank (Bild 5).
Für die Beispielanwendungwird eine Testdatenbank in MySQL angelegt(Bild 5)
Krypczyk
Im nächsten Schritt muss die Datenbankkonfiguration angepasst werden. Eine Grundvoraussetzung ist es, dass sowohl die PDO-PHP-Erweiterung als auch der PDO-Treiber für die im konkreten Fall verwendete Datenbank installiert wurde. Im konkreten Beispiel also für die MySQL-Datenbank. Wir gehen jetzt davon aus, dass dieses erfüllt ist. Die Konfiguration der Datenbankverbindung erfolgt über die Datei config/db.php des jeweiligen Yii-Projektes. Sofern Sie die Datenbank auch mit testdb bezeichnet haben, passen Sie den Inhalt wie folgt an:
<span class="php"><span class="hljs-meta"><?php</span></span>
<span class="php"><span class="hljs-keyword">return</span> [</span>
<span class="php"> <span class="hljs-string">'class'</span> => <span class="hljs-string">'yii\db\Connection'</span>,</span>
<span class="php"> <span class="hljs-string">'dsn'</span> => <span class="hljs-string">'mysql:host=localhost;dbname=testdb'</span>,</span>
<span class="php"> <span class="hljs-string">'username'</span> => <span class="hljs-string">'root'</span>,</span>
<span class="php"> <span class="hljs-string">'password'</span> => <span class="hljs-string">''</span>,</span>
<span class="php"> <span class="hljs-string">'charset'</span> => <span class="hljs-string">'utf8'</span>,</span>
<span class="php">];</span>
Auf die oben konfigurierte DB-Verbindung kann dann im Anwendungscode über den Ausdruck Yii::$app->db zugegriffen werden.Der Zugriff auf die Datenbank erfolgt im Yii-Framework über ActiveRecord-Klassen. Das ActiveRecord ist die objektorientierte Schnittstelle für den Zugriff auf die Daten, welche in Datenbanken gespeichert sind. Eine ActiveRecord-Klasse ist einer Datenbanktabelle zugeordnet, eine ActiveRecord-Instanz entspricht einer Zeile dieser Tabelle, und ein Attribut einer ActiveRecord-Instanz repräsentiert den Wert einer bestimmten Spalte in dieser Zeile. Die Nutzung dieser Klassen vermeidet das Schreiben von direkten SQL-Statements im Quellcode. Stattdessen arbeitet man mit den Attributen und den Methoden der ActiveRecord-Klassen. Ein Beispiel: Angenommen, Kunde ist eine ActiveRecord-Klasse, die der Kundentabelle zugeordnet ist, und Name ist eine Spalte der Kundentabelle. Die betreffenden Klassen werden im Ordner app\models abgelegt. In diesem Fall heißt die Klasse products. Jede ActiveRecord-Klasse leitet von der Basisklasse ActiveRecord ab. Wichtig ist: Sie müssen keinen spezifischen Code schreiben. Mit der Ableitung von der Basisklasse und der Übereinstimmung des Klassennamens mit der Tabellenbezeichnung haben wir schon alles erledigt. Das Framework Yii leitet den Tabellennamen aus dem Klassennamen ab. Möchten Sie hier eine Abweichung zwischen Klassen- und Tabellennamen umsetzen, dann müssen Sie die Methode yii\db\ActiveRecord::tableName() überschreiben, um den zugehörigen Tabellennamen explizit anzugeben. Die ActiveRecord-Klasse für die Tabelle products sieht dann wie folgt aus:
<?php
namespace app\models;
use yii\db\<span class="hljs-type">ActiveRecord</span>;
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Products</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">ActiveRecord</span></span>
{
.....
}
Die Verwendung der Klasse products ist dann sehr einfach. Blicken wir in die generierte Tabelle (siehe das Tool phpMyAdmin), dann finden Sie die folgenden Spaltennamen für die Beispieltabelle: productid, productCode, quantity und price. Möchte man dann aus dem Quellcode auf ein konkretes Attribut eines Datensatzes zugreifen, dann geht das wie folgt:
$products = Product::find()->orderBy(<span class="hljs-string">'name'</span>)->all();
$product = Product::findOne(<span class="hljs-string">'Pencil 2H'</span>);
<span class="hljs-keyword">echo</span> $product->name;
Die Klasse product bietet beispielsweise durch die Ableitung von der Klasse ActiveRecord die Methoden find() und findOne() zum Selektieren von Datensätzen. Ein konkreter Datensatz wird dann einem Objekt der Klasse product zugeordnet. Über die Attribute dieser Klasse kann dann auf die Werte des Datensatzes zugegriffen werden. In diesem Fall ist es das Attribut name.Hier nochmals der wichtige Hinweis: Sie müssen die individuellen Attribute in den ActiveRecord-Klassen nicht manuell erstellen. Über die Basisklasse sucht sich das Yii-Framework die entsprechenden Spalten in der Datenbanktabelle und stellt diese als Attribute der Klasse zur Verfügung.Damit ist erklärt, wie man aus einer Yii-Anwendung heraus grundsätzlich auf die Daten in der Datenbank zugreift. Durch das Konzept der ActiveRecord-Klassen wird dieses Vorgehen von der konkreten Datenbank abstrahiert und Sie müssen sich weder mit Treibern für die Datenbank noch mit SQL-Statements abmühen. Neben den relationalen Datenbanken können auch die genannten NoSQL-Datenbanken auf diese Weise angebunden werden. ActiveRecord-Klassen kommen also auch hier zum Einsatz.In der Dokumentation findet man die Beschreibung der Methoden, Properties usw. der ActiveRecord-Klasse. Man programmiert dann lediglich gegen diese Klasse statt gegen die Schnittstellen einer konkreten Datenbank.
Yii-Code-Generatorengenerieren ActiveRecord-Klassen automatisch(Bild 6)
Krypczyk
Das Yii-Framework generiertdie Model-Klassen eigenständig(Bild 7)
Krypczyk
Yii CRUD-Generatorliefert Vorlagen für die Views der Basismethoden für den Datenbankzugriff(Bild 8)
Krypczyk
Das Yii-Framework bietet im Bereich der Datenbankanbindung noch umfassendere Unterstützung. Über die Yii-Code-Generatoren können Sie die ActiveRecord-Klassen nach Auswahl der Datenbank und der Datentabelle automatisch generieren lassen. In diesem Fall verwenden Sie den Model-Generator (Bild 6). Im Ergebnis wird die entsprechende Model-Klasse, also die konkrete ActiveRecord-Klasse erstellt (Bild 7). Das kann man zunächst in der Vorschau machen und dann die Klasse im Dateisystem ablegen lassen.Auch weitere Klassen kann man erstellen lassen. Beispielsweise mittels des CRUD-Generators (Bild 8) Vorlagen für die Views der Basismethoden für den Datenbankzugriff, also Create, Read, Update und Delete.
Fazit
Das Yii-Framework bietet eine Unterstützung beim Zugriff auf Datenbanken. Dabei geht es weniger um den konkreten Zugriff als vielmehr um das Abbilden der entsprechenden Datenstruktur im Speicher in Form von Objekten. Dabei werden mehrere Aufgaben durch Tools unterstützt. Zum einem kann man eine bestehende Datenbank anzapfen und die Modelklassen durch den Yii-Code-Generator erstellen lassen (Prinzip: Database first). Zum anderen kann man auch aus bestehenden Modellklassen die Datenbankzugriffsmethoden (CRUD-Operationen) automatisch generieren.Diese Artikelserie hat einen Einblick in die Funktionen und die Arbeitsweise mit dem PHP-Framework Yii gegeben. Für die Kernfeatures einer komplexen PHP-Anwendung werden vorbereitete Lösungen angeboten, das heißt, für die Umsetzung des MVC-Musters mit der Generierung von Model, View und Controller-Klassen. Ebenso ist ein Konzept für das Routing und die Anbindung von Datenbanken vorhanden. Hilfreich sind auch die Code-Generatoren, welche im Entwicklungsprozess viel Arbeit ersparen können. Insgesamt bleibt es eine persönliche Entscheidung, ob man ein Framework wie Yii einsetzt, sich dann auch in dieses einarbeitet und vertieft oder ob man seine eigene Logik realisiert. Gerade für Entwickler, welche den Tech Stack auch wechseln, ist das Yii-Framework gut geeignet, eine Anwendungsstruktur vorzugeben. Man startet dann direkt durch und kann sich auf seine Anforderungen konzentrieren.Links zum Thema
<b>◼ <a href="https://www.yiiframework.com" rel="noopener" target="_blank">Yii-Framework</a> <br/></b>
