Le modèle de référentiel dans Laravel 5

Le modèle de référentiel a été introduit pour la première fois par Eric Evans dans son livre Domain-Driven Design. Le référentiel est en fait le point d’entrée de la application accéder au domaine couche.

En termes simples, le référentiel permet à tout votre code d'utiliser des objets sans avoir à savoir comment les objets sont persistés. Le référentiel contient toutes les connaissances de la persistance, y compris le mappage des tables aux objets. Cela fournit une vue plus orientée objet de la couche de persistance et rend le code de mappage plus encapsulé.

Le seul moyen de faire fonctionner vos référentiels dans Laravel (en tant que véritable référentiel - Manuel de conception piloté par domaine par Eric Evans) consiste à modifier l'ORM par défaut de l'enregistrement actif au mappeur de données. Le meilleur substitut est Doctrine.

La doctrine ORM

Doctrine est un ORM (mappage relationnel objet) qui implémente le modèle de mappeur de données et vous permet de séparer proprement les règles de gestion de l'application de la couche de persistance de la base de données. Doctrine utilise DQL plutôt que SQL. DQL vous apporte un langage de requête d'objet, ce qui signifie qu'au lieu d'un terme de requête relationnel traditionnel, vous auriez des requêtes en terme d'objet.

Il vous permet d'écrire les requêtes de base de données de manière orientée objet et vous aide lorsque vous devez interroger la base de données d'une manière qui ne peut pas être obtenue à l'aide des méthodes de référentiel par défaut. À mon avis, DQL est le moyen le plus puissant de rester en contact avec votre base de données..

Doctrine vs. Eloquent

Les entités Doctrine sont simplement une simple classe PHP et n’ajoutent pas de surcharge à un héritage ORM. Doctrine gère plusieurs requêtes avec le même héritage sans toucher à la base de données, ce qui signifie que l'objet d'entité existe pour toute la requête..

L'autre fonctionnalité intéressante de Doctrine est qu'au lieu de migrer des fichiers pour créer le schéma de base de données, la base de données est automatiquement créée pour refléter les métadonnées dans les annotations d'entité. D'autre part, Eloquent est moins compliqué et très facile à utiliser.

Une comparaison complète entre ces deux nécessiterait un article séparé. Comme vous pouvez le constater, un objet Doctrine est plus léger et plus abstrait. Cependant, Doctrine ne s’adaptant qu’à des projets spécifiques, elle peut donc vous occasionner parfois des frais généraux. Je crois que cela dépend du programmeur de choisir le meilleur ORM pour l'application.

L'application de blog

Il est maintenant temps de créer une application de blog avec Laravel. Premièrement, nous devons mettre en place Doctrine. Un pont permet de faire correspondre la configuration existante de Laravel 5. Pour installer Doctrine 2 dans notre projet Laravel, nous exécutons la commande suivante:

compositeur bash exige laravel-doctrine / orm

Comme d'habitude, le paquet devrait être ajouté à la app / config.php , en tant que prestataire de services:

php LaravelDoctrine \ ORM \ DoctrineServiceProvider :: class,

L'alias devrait également être configuré:

php 'EntityManager' => LaravelDoctrine \ ORM \ Facades \ EntityManager :: class

Enfin, nous publions la configuration du paquet avec:

bash vendeur artisan: publish --tag = "config"

Maintenant nous avons fini ici.

Les entités sont des éléments importants de l'application App \ Entities \ Post.php:

"php

espace de noms App \ Entity;

utilisez Doctrine \ ORM \ Mapping comme ORM;

/ ** * @ORM \ Entity * @ORM \ Table (name = ”posts”) * @ORM \ HasLifecycleCallbacks () * / class Post / ** * @var entier $ id * @ORM \ Column (name = ” id ”, type =” entier ”, unique = true, nullable = false) * @ORM \ Id * @ORM \ GeneratedValue (stratégie =" AUTO ") * * / private $ id;

/ ** * @ORM \ Column (type = "chaîne") * / private $ title; / ** * @ORM \ Column (type = "text") * / private $ body; fonction publique __construct ($ input) $ this-> setTitle ($ input ['title']); $ this-> setBody ($ input ['body']);  fonction publique setId ($ id) return $ this-> id = $ id;  fonction publique getId () return $ this-> id;  fonction publique getTitle () return $ this-> title;  fonction publique setTitle ($ title) $ this-> title = $ title;  fonction publique getBody () return $ this-> body;  fonction publique setBody ($ body) $ this-> body = $ body;  "

Maintenant il est temps de créer le Dépôt, qui a été décrit plus tôt. App / Dépôts / PostRepo.php :

"espace de noms php App \ Repository;

utilisez App \ Entity \ Post; utilisez Doctrine \ ORM \ EntityManager; classe PostRepo

/ ** * Chaîne @var * / private $ class = 'App \ Entity \ Post'; / ** * @var EntityManager * / private $ em; fonction publique __construct (EntityManager $ em) $ this-> em = $ em;  fonction publique create (Post $ post) $ this-> em-> persist ($ post); $ this-> em-> flush ();  mise à jour de la fonction publique (Post $ post, $ data) $ post-> setTitle ($ data ['title']); $ post-> setBody ($ data ['body']); $ this-> em-> persister ($ post); $ this-> em-> flush ();  fonction publique PostOfId ($ id) return $ this-> em-> getRepository ($ this-> class) -> findOneBy (['id' => $ id]);  fonction publique delete (Post $ post) $ this-> em-> remove ($ post); $ this-> em-> flush ();  / ** * create Post * @return Post * / fonction privée perpareData ($ data) retour new post ($ data);  

"

Le controlle: App / Http / Contrôleurs / PostController.php :

"espace de noms php App \ Http \ Controllers; utilisez App \ Repository \ PostRepo comme référentiel; utilisez App \ Validation \ PostValidator;

la classe PostController étend Controller private $ repo;

fonction publique __construct (repo $ repo) $ this-> repo = $ repo;  fonction publique edit ($ id = NULL) return View ('admin.edit') -> avec (['data' => $ this-> repo-> postOfId ($ id)]);  fonction publique 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); Session :: flash ('msg', 'edit success');  else $ this-> repo-> create ($ this-> repo-> perpare_data ($ all)); Session :: flash ('msg', 'add success');  renvoyer redirect () -> back ();  fonction publique retrieve () return View ('admin.index') -> avec (['Data' => $ this-> repo-> retrieve ()]);  fonction publique delete () $ id = Input :: get ('id'); $ data = $ this-> repo-> postOfId ($ id); if (! is_null ($ data)) $ this-> repo-> delete ($ data); Session :: flash ('msg', 'opération réussie'); return redirect () -> back ();  else return redirect () -> back () -> withErrors ('operationFails');  "

Comme vous le voyez, j'ai utilisé l'aide de Flash pour gérer les messages (vous pouvez utiliser celui de Laravel). En ce qui concerne le validateur, je devrais ajouter que vous pouvez créer le vôtre (comme je le fais) ou utiliser la valeur par défaut de Laravel, selon vos préférences..

Les fichiers de vue sont les mêmes que d’habitude. Dans cet exemple de vue, le fichier semble être ressources / views / admin / edit.blade.php :

"php

@if (Session :: has ('flash_notification.message')) × !! Session :: get ('flash_notification.message') !! @endif @if ($ errors-> has ()) @foreach ($ errors-> all () comme $ error)

• !! $ error !!

@endforeach @endif