Share
Als PHP-Entwickler sind Sie möglicherweise auf den Begriff ORM gestoßen. ORM ist eine Möglichkeit, mit Datenbanken auf dieselbe Weise wie mit Klassen und Objekten zu arbeiten. Wenn Sie sich eingehender damit befassen würden, wie Webanwendungen entworfen und erstellt werden, würden Sie nach einigen Erkundungen in ihrem ORM zwei bekannte Muster finden: Aktiver Rekord und Data Mapper.
Active Record bezieht sich auf die Zuordnung eines Objekts zu einer Datenbankzeile. In der Tat ist jede Zeile in der Datenbank an ein Objekt gebunden. Wenn Sie eine Zeile aus der Datenbank abrufen, können Sie das Objekt selbst aktualisieren, löschen oder speichern. So funktionieren Eloquent und Paris und wie es in Ruby on Rails gemacht wird.
Auf der anderen Seite, Data Mapper ist eine Softwareschicht, die die In-Memory-Objekte von der Datenbank trennt. Mit Data Mapper müssen die In-Memory-Objekte nicht wissen, dass sogar eine Datenbank vorhanden ist. Sie benötigen keinen SQL-Schnittstellencode oder Kenntnisse des Datenbankschemas. Eine solche Lösung ist die Lehre.
Doctrine ist ein ORM, der das Data-Mapper-Muster implementiert und die saubere Trennung der Geschäftsregeln der Anwendung von der Persistenzschicht der Datenbank ermöglicht.
Einige der Vorteile, die ich bei der Verwendung von Doctrine with Laravel entdeckte, sind:
Accentsconagua
Transaktionsrückschreiben Methodik ermöglicht Doctrine weniger Interaktion mit der Datenbank bis zum spülen() Methode wird aufgerufen.Doctrine hat natürlich auch Nachteile, aber es liegt am Programmierer, den richtigen ORM zu wählen.
DQL steht für Doctrine Query Language. DQL bietet Ihnen Objektabfragesprache, dh, anstelle einer herkömmlichen relationalen Abfrage haben Sie Abfragen in Objektform.
Mit DQL können Sie Datenbankabfragen objektorientiert schreiben. Dies ist hilfreich, wenn Sie die Datenbank auf eine Weise abfragen möchten, die mit den Standard-Repository-Methoden nicht erreicht werden kann (oder sehr schwierig ist).
Beispiel-DQL-Abfrage:
sql SELECT b.id als ItemId, b.title als ItemTitle, b.url als ItemUrl FROM Alireza \ Domain \ Identity \ Entities \ Menu u WHERE u.id =: id
Doctrine ermöglicht es Ihnen, Abfrageergebnisse mit Filtern zu begrenzen. Beispielsweise möchten Sie möglicherweise nur die Informationen des angemeldeten Benutzers bearbeiten oder sicherstellen, dass die aktuellen Kundendaten aus der Datenbank zurückgegeben wurden. Ein Filter ist eine automatische Lösung zum Erkennen spezifischer Bedingungen für alle Ihre Abfragen.
Doctrine enthält Einschränkungen auf SQL-Ebene, sodass die Klausel nicht in mehreren Repositorys Ihres Projekts verwaltet werden muss. Dies erhöht die Sicherheit und macht Ihren Code leichter lesbar.
Schauen wir uns ein Beispiel an:
php / ** * @ManyToOne (targetEntity = "Benutzer") * @JoinColumn (name = "user_id", referencedColumnName = "id") ** / private $ user; Wie Sie in der Benutzerentität sehen können, ist das Ergebnis von JoinColumn ist nur auf Artikel mit der Bedingung von beschränkt WHERE benutzer_id =: benutzer_id.
Um Doctrine einzurichten, gibt es eine Brücke, die eine Anpassung an die vorhandene Konfiguration von Laravel 5 ermöglicht. Um Doctrine 2 in unserem Laravel-Projekt zu installieren, führen wir den folgenden Befehl aus:
Bash-Komponist benötigt Laravel-Doktrin / Orm
Wie üblich sollte das Paket dem hinzugefügt werden app / config.php, als Dienstleister:
PHP LaravelDoctrine \ ORM \ DoctrineServiceProvider :: Klasse,
Der Alias sollte auch konfiguriert werden:
php 'EntityManager' => LaravelDoctrine \ ORM \ Facades \ EntityManager :: Klasse
Zum Schluss veröffentlichen wir die Paketkonfiguration mit:
bash php handwerker hersteller: publish --tag = "config"
Doctrine benötigt keine Datenbankkonfiguration und verwendet die aktuelle Laravel-Konfiguration. Wenn Sie sie jedoch überschreiben möchten, sollten Sie die Doctrine-Konfigurationsdatei in ändern Config / doctrine.php:
"php" manager "=> ['default' => ['dev' => env ('APP_DEBUG'), 'meta' => env ('DOCTRINE_METADATA', 'annotations'), 'verbindung' => env (' DB_CONNECTION ',' mysql '),' namespaces '=> [' App '],
"Das ist alles dazu.
"Entität" bezieht sich auf ein Objekt, das eine eindeutige Identität hat. Eine Entität muss über eine bestimmte Kennung verfügen, die im gesamten System eindeutig ist, z. B. ein Kunde oder ein Student. Es gibt andere Objekte, z. B. E-Mail-Adressen, die keine Entitäten sind, sondern Wertobjekte.
Lassen Sie uns ein Post-Objekt erstellen App / Unternehmen / Post.php:
"PHP-Namensraum App \ Entity;
Doctrine \ ORM \ Mapping als ORM verwenden;
/ ** * @ORM \ Entity * @ORM \ Table (name = "posts") * @ORM \ HasLifecycleCallbacks () * / class Post / ** * @var Integer $ id * @ORM \ Spalte (name = ") id ”, type =” integer ”, unique = true, nullable = false) * @ORM \ Id * @ORM \ GeneratedValue (Strategie =” AUTO ”) * * / private $ id;
/ ** * @ORM \ Column (type = "string") * / private $ title; / ** * @ORM \ Column (type = "text") * / private $ body; öffentliche Funktion __construct ($ input) $ this-> setTitle ($ input ['title']); $ this-> setBody ($ input ['body']); public function getId () return $ this-> id; public function getTitle () return $ this-> title; public function setTitle ($ title) $ this-> title = $ title; public function getBody () return $ this-> body; public function setBody ($ body) $ this-> body = $ body; "
Die Klasseneigenschaften sollten mit den Feldern in der Datenbanktabelle identisch sein, oder Sie können sie mit definieren @Colum ("name" = "myfield") Anmerkung.
Das Repository ermöglicht es Ihrem gesamten Code, Objekte zu verwenden, ohne zu wissen, wie die Objekte persistent sind. Das Repository enthält alle Kenntnisse über Persistenz, einschließlich der Zuordnung von Tabellen zu Objekten. Dies bietet eine objektorientiertere Ansicht der Persistenzschicht und macht den Mapping-Code stärker gekapselt.
Jetzt ist es an der Zeit, das zu erstellen Repository im App / Repository / PostRepo.php:
"php namespace App \ Repository; benutze App \ Entity \ Post; benutze Doctrine \ ORM \ EntityManager;
Klasse PostRepo
/ ** * @var string * / private $ class = 'App \ Entity \ Post'; / ** * @var EntityManager * / private $ em; öffentliche Funktion __construct (EntityManager $ em) $ this-> em = $ em; public function create (Post $ post) $ this-> em-> persist ($ post); $ this-> em-> flush (); public function update (Post $ post, $ data) $ post-> setTitle ($ data ['title']); $ post-> setBody ($ data ['body']); $ this-> em-> persist ($ post); $ this-> em-> flush (); public function PostOfId ($ id) return $ this-> em-> getRepository ($ this-> class) -> findOneBy (['id' => $ id]); öffentliche Funktion delete (Post $ post) $ this-> em-> remove ($ post); $ this-> em-> flush (); / ** * Post erstellen * @return Post * / private Funktion prepareData ($ data) neuen Post zurückgeben ($ data);
"
Die Lehre EntityManager fungiert als Zugangspunkt für die vollständige Verwaltung Ihrer Entitäten. Dann erstellen Sie den Controller App / HTTP / Controller / PostController.php:
"php namespace App \ Http \ Controllers; benutze App \ Repository \ PostRepo als Repo; benutze App \ Validation \ PostValidator;
Klasse PostController erweitert Controller private $ repo;
öffentliche Funktion __construct (repo $ repo) $ this-> repo = $ repo; public function edit ($ id = NULL) return View ('admin.index') -> mit (['data' => $ this-> repo-> postOfId ($ id)]); public function editPost () $ all = Eingabe :: all (); $ validate = PostValidator :: validate ($ all); if (! $ validate-> passt ()) return redirect () -> back () -> withInput () -> withErrors ($ validate); $ Id = $ this-> repo-> postOfId ($ all ['id']); if (! is_null ($ Id)) $ this-> repo-> update ($ Id, $ all); Session :: flash ('msg', 'Erfolg bearbeiten'); else $ this-> repo-> create ($ this-> repo-> perpare_data ($ all)); Session :: flash ('msg', 'add success'); return redirect () -> zurück (); public function retrieve () return View ('admin.index') -> mit (['Data' => $ this-> repo-> retrieve ())); public function delete () $ id = Eingabe :: get ('id'); $ data = $ this-> repo-> postOfId ($ id); if (! is_null ($ data)) $ this-> repo-> delete ($ data); Session :: flash ('msg', 'operation success'); return umleiten () -> zurück (); else return redirect () -> back () -> withErrors ('operationFails'); "Ansicht und Routing sind wie gewohnt. Ich bevorzuge die Erstellung eines eigenen Validators basierend auf der Validator-Klasse von Laravel. Hier ist der Validator App \ Validation \ PostValidator.php:
"php Namespace App \ Validation; verwenden Sie Validator;
class PostValidator öffentliche statische Funktion validate ($ input) $ rules = ['title' => 'Erforderlich | Min: 4 | Max: 80 | alpha_spaces', 'body' => 'Required',]; return Validator :: make ($ input, $ rules); "
Wenn Sie noch nicht mit Doktrin 2 gearbeitet haben, hoffe ich, dass dieser Artikel interessant und informativ war. Laravel 5 verwendet Doctrine nicht, aber wie Sie sehen, gibt es einige Pakete, die es uns ermöglichen, sie leicht mit Laravel zu verwenden. Ich habe eine einfache Blog-App mit Laravel 5 und Doctrine ORM erstellt, und ich hoffe, dass Ihnen dies helfen kann, die gewünschte App zu erstellen. Ich begrüße Ihre Kommentare.
