Share
Als PHP-ontwikkelaar bent u misschien de term ORM tegengekomen. ORM is een manier om met databases te werken op dezelfde manier als u met klassen en objecten werkt. Als je dieper in zou gaan met het ontwerpen en bouwen van webtoepassingen, zou je na wat verkennen in hun ORM twee bekende patronen vinden: Actieve record en Data Mapper.
Actieve record verwijst naar het toewijzen van een object aan een databaserij. Inderdaad, elke rij in de database is gekoppeld aan een object. Wanneer u een rij uit de database ophaalt, kunt u deze bijwerken, verwijderen of opslaan met behulp van het object zelf. Dat is hoe Eloquent en Parijs werken, en hoe het wordt gedaan in Ruby on Rails.
Anderzijds, Data Mapper is een softwarelaag die de objecten in het geheugen van de database scheidt. Met Data Mapper hoeven de objecten in het geheugen niet te weten dat er zelfs een database aanwezig is. Ze hebben geen SQL-interfacecode of kennis van het databaseschema nodig. Een dergelijke oplossing is Doctrine.
Doctrine is een ORM die het patroon van de gegevensmap implementeert en waarmee u een schone scheiding kunt aanbrengen tussen de bedrijfsregels van de toepassing en de persistentielaag van de database.
Enkele van de voordelen die ik ontdekte tijdens het gebruik van Doctrine met Laravel zijn:
Accentsconagua
Transactionele achterstand methodologie laat Doctrine minder interactie met de Database tot stand komen flush () methode wordt genoemd.Natuurlijk heeft Doctrine ook nadelen, maar het is aan de programmeur om de juiste ORM te kiezen.
DQL staat voor Doctrine Query Language. DQL brengt je objectquerytaal, wat betekent dat je in plaats van een traditionele relationele query query's in objectvorm hebt.
Met DQL kunt u databasequery's op een objectgerichte manier schrijven, wat handig is wanneer u de database moet bevragen op een manier die niet kan worden bereikt (of zeer moeilijk is) met behulp van de standaard repositorymethoden.
Voorbeeld DQL Query:
sql SELECTEER b.id als ItemId, b.title als ItemTitle, b.url als ItemUrl FROM Alireza \ Domain \ Identity \ Entities \ Menu u WHERE u.id =: id
Met Doctrine kunt u queryresultaten beperken met filters. U wilt bijvoorbeeld misschien alleen de informatie van de ingelogde gebruiker bewerken of ervoor zorgen dat de gegevens van de huidige klant uit de database zijn teruggekomen. Een filter is een automatische oplossing voor het onthouden van specifieke voorwaarden voor al uw vragen.
Doctrine biedt beperkingen op SQL-niveau, dus het is niet nodig om de clausule in meerdere repositories van uw project te behouden. Dit verbetert de beveiliging en maakt uw code leesbaarder.
Laten we een voorbeeld bekijken:
php / ** * @ManyToOne (targetEntity = "Gebruiker") * @JoinColumn (name = "user_id", referencedColumnName = "id") ** / private $ user; Zoals u in de User-entiteit kunt zien, is het resultaat van JoinColumn is beperkt tot alleen items met de voorwaarde van WHERE user_id =: user_id.
Om Doctrine op te zetten, is er een brug om toe te voegen aan de bestaande configuratie van Laravel 5. Om Doctrine 2 in ons Laravel-project te installeren, voeren we het volgende commando uit:
bash-componist heeft laravel-doctrine / orm nodig
Zoals gebruikelijk, moet het pakket worden toegevoegd aan de app / config.php, als de dienstverlener:
php LaravelDoctrine \ ORM \ DoctrineServiceProvider :: class,
De alias moet ook worden geconfigureerd:
php 'EntityManager' => LaravelDoctrine \ ORM \ Facades \ EntityManager :: klasse
Ten slotte publiceren we de pakketconfiguratie met:
bash php artisan verkoper: publiceer --tag = "config"
Doctrine heeft geen databaseconfiguratie nodig en gebruikt de huidige Laravel-configuratie, maar als u deze wilt overschrijven, moet u het Doctrine-configuratiebestand wijzigen in Config / doctrine.php:
"php 'managers' => ['default' => ['dev' => env ('APP_DEBUG'), 'meta' => env ('DOCTRINE_METADATA', 'annotaties'), 'connection' => env (' DB_CONNECTION ',' mysql '),' namespaces '=> [' App '],
"Dat is alles wat er is.
"Entiteit" verwijst naar een object met een duidelijke identiteit. Een entiteit moet een specifieke identificatie hebben die uniek is in het gehele systeem, zoals een klant of een student. Er zouden andere objecten zijn, zoals e-mailadressen, die geen entiteiten zijn, maar waardeobjecten.
Laten we een berichtentiteit maken App / Entity / post.php:
"php namespace App \ Entity;
gebruik Doctrine \ ORM \ Mapping als ORM;
/ ** * @ORM \ Entity * @ORM \ Table (name = "posts") * @ORM \ HasLifecycleCallbacks () * / class Post / ** * @var integer $ id * @ORM \ Column (name = " id ", type =" integer ", unique = true, nullable = false) * @ORM \ Id * @ORM \ GeneratedValue (strategy =" AUTO ") * * / private $ id;
/ ** * @ORM \ Column (type = "string") * / private $ title; / ** * @ORM \ Column (type = "text") * / private body $; openbare functie __construct ($ input) $ this-> setTitle ($ input ['title']); $ This-> setBody ($ input [ 'body']); openbare functie getId () return $ this-> id; openbare functie getTitle () return $ this-> title; openbare functie setTitle ($ title) $ this-> title = $ title; openbare functie getBody () return $ this-> body; public function setBody ($ body) $ this-> body = $ body; "
De klasse-eigenschappen moeten dezelfde zijn als de velden in de databasetabel, of u kunt ze definiëren met de @Colum ( "naam" = "myfield") aantekening.
Met de repository kan al uw code objecten gebruiken zonder dat u weet hoe de objecten worden bewaard. De repository bevat alle kennis van persistentie, inclusief het toewijzen van tabellen aan objecten. Dit biedt een meer objectgeoriënteerde weergave van de persistentielaag en maakt de toewijzingscode meer ingekapseld.
Nu is het tijd om het te maken bewaarplaats in App / Repository / PostRepo.php:
"php namespace App \ Repository; gebruik App \ Entity \ Post; use Doctrine \ ORM \ EntityManager;
class PostRepo
/ ** * @var string * / private $ class = 'App \ Entity \ Post'; / ** * @var EntityManager * / private $ em; openbare functie __construct (EntityManager $ em) $ this-> em = $ em; public function create (Post $ post) $ this-> em-> persist ($ post); $ This-> EM> flush (); update openbare functie (Post $ post, $ gegevens) $ post-> setTitle ($ data ['title']); $ Post-> setBody ($ data [ 'body']); $ This-> EM> aanhouden ($ post); $ This-> EM> flush (); openbare functie PostOfId ($ id) retourneer $ this-> em-> getRepository ($ this-> class) -> findOneBy (['id' => $ id]); public function delete (Post $ post) $ this-> em-> remove ($ post); $ This-> EM> flush (); / ** * create Post * @return Post * / private function prepareData ($ data) return new Post ($ data);
"
De doctrine EntityManager werkt als het toegangspunt voor het volledige beheer van uw entiteiten. Creëer vervolgens de controller App / Http / Controllers / PostController.php:
"php namespace App \ Http \ Controllers; gebruik App \ Repository \ PostRepo als repo; gebruik App \ Validation \ PostValidator;
class PostController verlengt Controller private $ repo;
openbare functie __construct (repo $ repo) $ this-> repo = $ repo; public function edit ($ id = NULL) return View ('admin.index') -> with (['data' => $ this-> repo-> postOfId ($ id)]); public function editPost () $ all = Input :: all (); $ validate = PostValidator :: validate ($ all); if (! $ validate-> passes ()) return redirect () -> back () -> withInput () -> withErrors ($ validate); $ Id = $ this-> repo-> postOfId ($ all ['id']); if (! is_null ($ Id)) $ this-> repo-> update ($ Id, $ all); Sessie :: flash ('msg', 'edit success'); else $ this-> repo-> create ($ this-> repo-> perpare_data ($ all)); Sessie :: flash ('msg', 'succes toevoegen'); return redirect () -> back (); public function retrieve () return View ('admin.index') -> with (['Data' => $ this-> repo-> retrieve ()]); public function delete () $ id = Input :: get ('id'); $ data = $ this-> repo-> postOfId ($ id); if (! is_null ($ data)) $ this-> repo-> delete ($ data); Sessie :: flash ('msg', 'operation Success'); return redirect () -> back (); else return redirect () -> back () -> withErrors ('operationFails'); "Beeld en routing zijn hetzelfde als gebruikelijk. Ik geef er de voorkeur aan om mijn eigen Validator te maken op basis van Laravel's Validator-klasse. Hier is de Validator App \ Validation \ PostValidator.php:
"php namespace App \ Validation; gebruik Validator;
class PostValidator public static function validate ($ input) $ rules = ['title' => 'Vereist | Min: 4 | Max: 80 | alpha_spaces', 'body' => 'Vereist',]; return Validator :: make ($ invoer, $ regels); "
Als je nog niet eerder met Doctrine 2 hebt gewerkt, hoop ik dat dit artikel interessant en informatief is geweest. Laravel 5 gebruikt Doctrine niet, maar zoals je kunt zien, zijn er enkele pakketten waarmee we het eenvoudig met Laravel kunnen gebruiken. Ik heb een eenvoudige blog-app gemaakt met Laravel 5 en Doctrine ORM en ik hoop dat dit je kan helpen bij het maken van je gewenste app. Ik verwelkom uw opmerkingen.
