Programmierung & Skripten

Einführung in das Lehre -ORM- und Data Mapper -Muster in PHP

Einführung in das Lehre -ORM- und Data Mapper -Muster in PHP

Zielsetzung

Erfahren Sie die grundlegenden Konzepte von Doctrine ORM und implementieren Sie das Data Mapper -Muster mit PHP.

Anforderungen

  • Komponist (PHP -Paketmanager)
  • Ein Arbeitslampen -Setup
  • Verständnis der grundlegenden objektorientierten Programmierung und PHP
  • Verständnis der grundlegenden Datenbankkonzepte

Konventionen

  • # - Erfordert, dass gegebene Linux -Befehle entweder mit Root -Berechtigungen ausgeführt werden müssen
    direkt als Stammbenutzer oder durch Verwendung von sudo Befehl
  • $ - Erfordert, dass die angegebenen Linux-Befehle als regelmäßiger nicht privilegierter Benutzer ausgeführt werden können

Einführung

Der Data Mapper -Muster ist ein architektonisches Muster, durch das es möglich ist, eine Trennung zwischen einer Datenpersistenzschicht (in diesem Fall eine MySQL-Datenbank) und einer Datendarstellung in Memory (in diesem Fall PHP-Objekte) zu erreichen, damit die beiden Ebenen getrennt und getrennt und Es ist sich völlig nicht bewusst, wodurch die Trennung von Bedenken respektiert.

In diesem Tutorial werden wir sehen, wie wir unsere ersten Schritte mit Doctrine, einer Data Mapper -Muster -Implementierung, ausführen, die Teil der ist Symfony PHP -Framework, kann aber auch von selbst verwendet werden.

Die Datenbankerstellung

Vor etwas anderem sollten wir die Datenbank erstellen, die wir für die Datenpersistenz verwenden werden. In diesem Tutorial werden wir einen Benutzer und seine Beiträge in einem Blog darstellen:

Mariadb [(Keine)]> Datenbank -Blog erstellen; Mariadb [(Keine)]> Geben Sie alle Privilegien im Blog zu.* Zu 'testuser'@'localhost' identifiziert durch 'testPassword'; Mariadb [(keine)]> Flush -Privilegien; Mariadb [(keine)]> exit;

Installieren und initialisieren Sie die Lehre

Der nächste Schritt auf unserer Reise ist die Installation der Doktrin: Wir werden verwenden Komponist, Das PHP -Paket und der Abhängigkeitsmanager. In der Wurzel unseres Projekts erstellen wir den Komponisten.JSON -Datei, angeben Doktrin/Orm Als Abhängigkeit:

"erfordern": "Doktrin/Orm": "^2.6 "
Kopieren

Um mit der Installation im selben Verzeichnis fortzufahren, öffnen Sie ein Terminal und laufen Sie aus:

$ Composer Install

Der Komponist installiert Doktrin und alle seine Abhängigkeiten innerhalb der Verkäufer Verzeichnis, das es erstellen wird. Sobald die Doktrin installiert ist, müssen wir sie initialisieren. Speichern Sie den folgenden Code in einer Datei (für dieses Tutorial nennen wir ihn Bootstrap.Php):

 'Blog'; 'user' => 'testuser', 'password' => 'testPassword', 'host' => 'localhost', 'treiber' => 'pdo_mysql']; // Erhalten Sie den Entity Manager $ entity_Manager = doctrine \ orm \ entityManager :: create ($ connection_parameters, $ configuration);
Kopieren

Erstens benötigten wir in Zeile 2 die Komponist -Autoloaddatei Autoload.Php, Das kümmert sich um das Autolading der benötigten Bibliotheken.

Durch Anruf die CreateAnnotationMetadataconfiguration statische Methode der Aufstellen Klasse in Zeile 5 haben wir begonnen, die Lehre einzurichten. Diese Methode nimmt 5 Argumente vor.

Das erste Argument in Zeile 6 ist eine Reihe von Pfaden, in denen Entitätsklassen in unserem Projekt zu finden sind. Eine Entität ist eine Klasse, die eine Zeile in der Datenbank darstellt (die oben erwähnte In-Memory-Rapresentation): In unserem Beispiel werden wir zwei Entitäten verwenden: Autor und Post.

Das zweite Argument in Zeile 7 nimmt einen booleschen Wert an und definiert, ob wir im „Dev“ -Modus arbeiten oder nicht. Dadurch definiert das Lehreverhalten über Proxy -Objekte und Caching: Wenn im „Dev“ -Modus Proxy -Objekte auf jeder Anfrage regeneriert werden, wird im Speicher auftreten, da angenommen wird, dass während der Entwicklung Änderungen sehr häufig vorkommen werden. Wir werden es vorerst auf wahr einstellen.

Danach müssen wir die Verbindungsparameter in den Zeilen 11-16 in Form eines assoziativen Arrays angeben, das in der Reihenfolge den Datenbanknamen, den Datenbankbenutzer, das Datenbankkennwort, den Datenbankhost und den Treiber zum Zugriff auf die Datenbank verwendet. Es ist wichtig zu bemerken, dass die Doktrin auf einer niedrigeren Ebene verwendet Pdo Um mit der Datenbank zu interagieren, ist sie als Datenbank-Agnostiker konzipiert.

Schließlich haben wir in Zeile 20 eine Instanz des EntityManager -Objekts erstellt und die Werksmethode "erstellen" der EntityManager -Klasse aufgerufen und das Array von Verbindungsinformationen übergeben, die wir gerade als erster Parameter und die Aufbau Objekt als zweites. Das EntityManager -Objekt bietet uns Zugang zu allen unseren Unternehmen und lässt uns in der Lage sein, ihre Beharrlichkeit und ihren Lebenszyklus leicht zu verwalten.

Unsere Einheiten schaffen

Es ist Zeit, unsere Einheiten zu schaffen. Genau wie wir in der Konfiguration erwähnt haben, werden wir in der Wurzel unseres Projekts ein Verzeichnis „Entitäten“ erstellen, um unsere Einheiten zu speichern. Die erste Einheit, die wir definieren werden, ist Autor:

Kopieren

Wir haben unsere erste, sehr einfache Entität definiert. Wir verwendeten Anmerkungen Um die erforderlichen Informationen zu geben, um sie zu verarbeiten. Zuerst in Zeile 5, verwendet, @Juristische Person Wir sagen die Doktrin, dass die Klasse als Einheit angesehen werden muss, die in der bestehen wird Autor Datenbanktabelle. In diesem Fall haben wir die Annotation @table (name = ”Autor”) in Zeile 6 verwendet, um dies anzugeben. In dieser Situation ist es jedoch überflüssig, und wir hätten sie vollständig weglassen können: es ist optional und wenn nicht verwendet, das Entität wird in einer nach dem benannten Tabelle bestehen unqualifiziert Klassenname.

Jede Eigenschaft der Klasse entspricht einer Spalte in der Tabelle, und wir müssen Informationen über den Tabellendatentyp bereitstellen. Der $ id Die Eigenschaft zum Beispiel repräsentiert den Primärschlüssel der Tabelle: Wir geben dies mit der Verwendung des @Ausweis Annotation in Zeile 11.

Der Wert der Ausweis Die Spalte wird automatisch generiert, deshalb haben wir die verwendet @GeneratedValue Annotation in Zeile 12. Es hat nur sinnvoll, wenn es verbunden ist @Ausweis, und indem Sie es verwenden, ist es sogar möglich, die zu verabschiedete Generationsstrategie anzugeben (wenn keine angegeben ist, wird sie standardmäßig angeben AUTO).

Der für unseren Hauptschlüssel verwendete Datentyp wird sein Smallint, was wir über die definiert haben @Column (type = "smallint") Annotation in Zeile 13. Die beiden anderen Eigenschaften sind $ First_Name und $ last_name, und sie sind mit derselben Technik definiert. Sie sind vom Typ Saite: Bei Verwendung von MySQL wird es in die übersetzt Varchar Datenbankdatentyp. Für eine vollständige Referenz zu Datentypverbänden können Sie diese Seite konsultieren.

Bei der Verwendung der Lehre kann die Sichtbarkeit der Eigenschaften einer Entitätsklasse entweder sein geschützt oder Privatgelände aber nicht öffentlich.

Wir haben Getter und Setter für die Klasse noch nicht definiert. Es besteht keine Notwendigkeit, das manuell zu tun, da die Doktrin dies für uns tun kann und wir sehen, wie wir gleich eine andere Einheit haben, um zu definieren, Post:

Kopieren

Wir haben zwei neue Datentypen eingeführt. Der erste ist Text In Zeile 23, die Stringdaten ohne maximale Länge zugeordnet und konvertiert: Bei Verwendung von MySQL wird sie in die konvertiert Longtext Datentyp. Der zweite ist Terminzeit in Zeile 28 für unsere $ Datum Eigentum. Es wird in den gleichen Typ für MySQL und in einer Instanz von PHPs übersetzt Terminzeit Objekt.

Jetzt können wir unsere Getter und Setter generieren, aber bevor wir das tun, müssen wir die erstellen Cli-Config.Php Skript in der Wurzel unseres Projekts: Es wird benötigt, um Doktrin aus der Befehlszeile zu verwenden:

Kopieren

Öffnen Sie nun eine Terminalschale im Stammverzeichnis des Projekts und führen Sie den folgenden Linux -Befehl aus:

$ PHP-Anbieter/Bin/Doktrin ORM: Generate-Entfaltungen .

Der obige Befehl generiert Getter und Setter für die gefundenen Entitäten und platziert sie in das angegebene Verzeichnis. Wenn wir uns jetzt das ansehen Autor Entität können wir sehen, dass Getter und Setter generiert wurden:

Ausweis;  /*** Setzen Sie den FirstName. * * @param String $ FirstName * * @return Autor */ public function setfirstname ($ FirstName) $ this-> first_name = $ FirstName; kehren Sie dies zurück;  /*** Erhalten Sie den erstenNamen. * * @return string */ public function getfirstName () return $ this-> first_name;  /*** LastName festlegen. * * @param String $ LastName * * @return Autor */ public function setLastName ($ lastName) $ this-> last_name = $ lastName; kehren Sie dies zurück;  /*** Holen Sie sich LastName. * * @return string */ public function getLastName () return $ this-> last_name;
Kopieren

Das gleiche ist für die passiert Post juristische Person:

Ausweis;  /*** Titel setzen. * * @param String $ title * * @return post */ public function settitle ($ title) $ this-> title = $ title; kehren Sie dies zurück;  /*** Title Holen Sie sich. * * @return String */ public function gettitle () return $ this-> title;  /** * Text setzen. * * @param String $ text * * @return post */ public function setText ($ text) $ this-> text = $ text; kehren Sie dies zurück;  /*** Text abrufen. * * @return string */ public function getText () return $ this-> text;  /** * Datum einstellen. * * @param \ DateTime $ Datum * * @return post */ public function setDate ($ date) $ this-> date = $ Datum; kehren Sie dies zurück;  /** * Verabredung bekommen. * * @return \ DateTime */ public function getDate () return $ this-> date;
Kopieren

Definieren der Beziehung zwischen den Entitäten

Für unser Beispiel wollen wir a definieren bidirektional zu vielen Beziehung zwischen unseren Unternehmen, wo bidirektional bedeutet, dass jedes Unternehmen einen Hinweis auf den anderen hat. Die Beziehung zwischen einem Autor und seinen Beiträgen ist viele zu eins (ein Autor kann viele Beiträge schreiben und viele Beiträge können einem Autor gehören). Die Verwendung von Doktrin ist sehr einfach, eine solche Assoziation zu definieren:

Kopieren

Wir haben in jedem Unternehmen eine neue Eigenschaft hinzugefügt. Im Autor ist es $ Beiträge in Zeile 16 und in der Posteinheit, $ Autor in Zeile 36. Welche Art von Datentyp gelten diese Variablen?? Der erste, $ Beiträge wird eine Instanz von Doktrin sein ArrayColletion Objekt: Es ist eine spezielle Klasse, mit der die Sammlung von Entitäten besser verwaltet wird.

Der zweite, $ Autor, In Post.Php, wird eine Instanz des Autor -Unternehmens sein, der den Autor der Post vertritt: Wie bereits erwähnt, hat jede Entität einen Hinweis auf den anderen.

Ähnlich wie wir für die anderen Eigenschaften getan haben, haben wir die Beziehung mit Annotationen definiert. In unserem Fall haben wir die verwendeten, da wir uns mit einer bidirektionalen Eins-zu-Viele-Beziehung befassen @Onetomany Annotation in Zeile 13 in der Autorentität und @Manytoone In Zeile 32 in Post.

In beiden Fällen mit Zielez Wir haben definiert, auf welches Unternehmen das Eigentum zeigt. Zum Beispiel im Fall des Autors $ Beiträge Eigenschaft, die Zieleinheit ist post. Wie Sie sehen können, haben wir jeweils die verwendet umgekehrt Und Zugeordnet Anmerkungen. Diese Anmerkungen werden verwendet, um die Doktrin zu sagen, welche Eigenschaft auf der anderen Seite der Beziehung auf das Objekt bezieht: umgekehrt muss in der Seite verwendet werden, der das gehört UNBEKANNTER SCHLÜSSEL, (In diesem Fall die Post -Entität).

Wie Sie sehen können, haben wir im Autor verwendet Zugeordnet, Angabe dessen in der Zielentität Post ist die entsprechende Eigenschaft $ Autor. Wir haben auch einen neuen Parameter eingeführt, Kaskade, Setzen Sie es auf "alle". Dies bedeutet, dass durch das Bestehen oder Entfernen der Entität aus der Datenbank auch alle ihre Beiträge beeinflusst werden: Beispielsweise verursacht das Löschen eines Benutzers auch die Löschung aller Beiträge seiner Beiträge. Ist das, was wir durch definieren Bei Löschen der Kaskade im SQL -Code.

Umgekehrt in der Post Entity, die den Fremdschlüssel in der Datenbank hält, haben wir verwendet umgekehrt, Die Lehre mitteilt, dass die Eigenschaft, die sich auf das Objekt bezieht Beiträge. Wir haben auch die benutzt @Joincolumn Annotation in Zeile 33, in der die Spalten angeben nicht nullbar (NICHT NULL).

Sobald die Beziehung zwischen den beiden Entitäten definiert ist, müssen wir die Methoden zur Verwaltung der zusätzlichen Eigenschaften aktualisieren. Wieder rennen wir einfach:

$ PHP-Anbieter/Bin/Doktrin ORM: Generate-Entfaltungen .

Generieren Sie das Datenbankschema

In unserem Beispiel haben wir genügend Daten, um unser Datenbankschema zu generieren. Auch hier kann die Doktrin uns helfen, indem sie sie automatisch auf basierend auf unseren Anmerkungen generieren. Alles, was wir tun müssen, ist, den folgenden Linux -Befehl auszuführen:

$ PHP-Anbieter/bin/Doktrin ORM: Schema-Tool: Update-Force

Wenn alles gut geht, werden die Datenbanktabellen generiert, prüfen wir es:

Mariadb [(Keine)]> Blog beschreiben.Autor; +------------+--------------+------+-----+------------ -+ ----------------+ | Feld | Typ | NULL | Schlüssel | Standard | Extra | +------------+--------------+------+-----+------------ -+ ----------------+ | id | smallint (6) | Nein | Pri | NULL | auto_increment | | First_Name | Varchar (255) | Nein | | NULL | | | last_name | Varchar (255) | Nein | | NULL | | +------------+--------------+------+-----+------------ -+ ----------------+ Mariadb [(keine)]> Blog beschreiben.Post; +-----------+--------------+------+-----+--------- + ----------------+ | Feld | Typ | NULL | Schlüssel | Standard | Extra | +-----------+--------------+------+-----+--------- + ----------------+ | id | smallint (6) | Nein | Pri | NULL | auto_increment | | Author_id | smallint (6) | Nein | Mul | NULL | | | Titel | Varchar (255) | Nein | | NULL | | | Text | longtext | Nein | | NULL | | | Datum | datetime | Nein | | NULL | | +-----------+--------------+------+-----+---------+----------------+
Kopieren

Wie erwartet wurden die Tabellen, die unserer Entität entsprechen. Der SQL -Code, der verwendet wird, um sie zu generieren, ist jeweils:

Mariadb [(Keine)]> SHOW CREATE TABLE BLOG.Autor; Tabelle: Autor erstellen Tabelle: Tabelle 'Autor' ('id' smallint (6) nicht null auto_increment, 'first_name' varchar (255) Collate utf8_unicode_ci nicht null, 'last_name' varchar (255) Collate utf8_unicode_ci nicht null, primärer Schlüssel (Primärschlüssel 'id'))) Engine = InnoDB Auto_increment = 2 Standard charSet = utf8 colate = utf8_unicode_ci mariadb [(keine)]> creat table blog anzeigen table table.Post; Tabelle: Post erstellen Tabelle: Erstellen Sie Tabelle 'Post' ('id' smallint (6) nicht null auto_increment, 'Author_id' smallint (6) nicht null, 'title' varchar (255) collate utf8_unicode_ci nicht null, 'text' longtext collate collate utf8_unicode_ci nicht null, 'Date' datetime nicht null, primärer Key ('id'), key 'idx_5a8a6c8df675f31b' ('Author_id'), Einschränkung 'fk_5a8a6c8df675f31b' Fremd Key ('Author_id'). Motor = InnoDB Auto_increment = 2 Standard charSet = utf8 colate = utf8_unicode_ci
Kopieren

Verwenden des Entity -Managers

Jetzt ist es Zeit, wie man das benutzt Entitätsleiter:

setfirstname ("John") -> setLastName ("Smith"); $ entity_Manager-> persist ($ author); // Erstellen Sie einen neuen Beitrag $ post = (neue Entitäten \ post ()) -> settitle ("Hallo Wold") -> setText ("Dies ist ein Testpost") -> SetAuthor ($ Autor) -> Setdate (neu Terminzeit()); // Fügen Sie den Beitrag zur Liste der Autorenbeiträge hinzu. Da wir Cascade = "All" verwendet haben, müssen wir den Beitrag nicht separat bestehen: Er wird bestehen bleiben, wenn der Autor $ Autor-> addpost ($ post) bestehen; // schließlich die Datenbanktransaktion $ entity_Manager-> flush () spülen und ausführen;
Kopieren

Durch Ausführung dieses Codes haben wir einen Autor und seinen ersten Beitrag erstellt, dann haben wir den Beitrag zur Postsammlung des Autors hinzugefügt und schließlich in die Datenbank bestehen bleiben. Mit dem fortdauern() Methode Wir fordern die Doktrin an, die Entität zu verwalten spülen(). Wenn wir uns jetzt das ansehen Autor Und Post In der Tabelle können wir sehen, dass in beiden eine neue Aufzeichnung besteht:

Mariadb [(keine)]> Auswahl * aus dem Blog.Autor; +----+------------+-----------+| id | First_Name | last_name | +----+------------+-----------+| 1 | John | Smith | +----+------------+-----------+mariadb [(keine)]> aus dem Blog auswählen.Post; +----+-----------+------------+------------------- -+ ----------------------+ | id | Author_id | Titel | Text | Datum | +----+-----------+------------+------------------- -+ ----------------------+ | 1 | 1 | Hallo Wold | Dies ist ein Testbeitrag | 2018-04-17 08:37:44 | +----+-----------+------------+---------------------+---------------------+
Kopieren

Wir können auch den Entity Manager verwenden, um eine vorhandene Entität abzurufen, z. B.:

// den Autor nach seinem Nachnamen $ $ author = $ entity_Manager-> getRepository ('Entities \ Author')-> findoneby (['last_name' => 'Smith']) abrufen;
Kopieren

Schlussfolgerungen

Das Ziel dieses Tutorials war es, Sie mithilfe der Doktrin in das Data Mapper -Muster in PHP vorzustellen: Wir haben gesehen.

Doctrine ist eine sehr leistungsstarke Bibliothek: Sie können die Projektdokumentation verwenden, um mit dem Mastern zu beginnen. Hoffentlich könnte dies ein minimaler Ausgangspunkt sein.

Verwandte Linux -Tutorials:

  • Dinge zu installieren auf Ubuntu 20.04
  • Ampache Raspberry Pi Installation
  • So erstellen Sie einen Docker -basierten Lampenstapel mit Docker auf…
  • So installieren Sie Lampenstapel auf Almalinux
  • Dinge zu tun nach der Installation Ubuntu 20.04 fokale Fossa Linux
  • Eine Einführung in Linux -Automatisierung, Tools und Techniken
  • Ubuntu 20.04 Tricks und Dinge, die Sie vielleicht nicht wissen
  • Mint 20: Besser als Ubuntu und Microsoft Windows?
  • Big Data Manipulation zum Spaß und Gewinn Teil 1
  • Ubuntu 20.04 WordPress mit Apache -Installation