Share
En tant que développeur PHP, vous avez peut-être rencontré le terme ORM. ORM permet de travailler avec des bases de données de la même manière que vous utilisez des classes et des objets. Si vous voulez approfondir la conception et la construction des applications Web, vous découvrirez deux modèles bien connus: Enregistrement actif et Data Mapper.
Enregistrement actif désigne le mappage d'un objet sur une ligne de la base de données. En effet, chaque ligne de la base de données est liée à un objet. Lorsque vous récupérez une ligne de la base de données, vous pouvez mettre à jour, supprimer ou enregistrer en utilisant l'objet lui-même. C’est comme ça que fonctionnent Eloquent et Paris, et comment cela se passe dans Ruby on Rails.
D'autre part, Data Mapper est une couche de logiciel qui sépare les objets en mémoire de la base de données. Avec Data Mapper, les objets en mémoire n'ont pas besoin de savoir qu'il existe même une base de données. Ils n'ont besoin d'aucun code d'interface SQL ni de connaissances du schéma de base de données. Une telle solution est Doctrine.
Doctrine est un ORM qui implémente le modèle de mappeur de données et vous permet de séparer proprement les règles de l'application de la couche de persistance de la base de données..
Certains des avantages que j'ai découverts lors de l'utilisation de Doctrine avec Laravel sont les suivants:
Accentsconagua
Écriture transactionnelle méthodologie permet à Doctrine d’avoir moins d’interactions avec la base de données jusqu’à ce que le affleurer() la méthode s'appelle.Bien sûr, Doctrine a aussi des inconvénients, mais il appartient au programmeur de choisir le bon ORM..
DQL signifie Doctrine Query Language. DQL vous apporte le langage de requête d'objet, ce qui signifie qu'au lieu d'une requête relationnelle traditionnelle, vous avez des requêtes sous forme d'objet.
DQL vous permet d'écrire des requêtes de base de données de manière orientée objet, ce qui est utile lorsque vous devez interroger la base de données d'une manière qui ne peut pas être réalisée (ou est très difficile) à l'aide des méthodes de référentiel par défaut..
Exemple de requête DQL:
sql SELECT b.id comme ItemId, b.title comme ItemTitle, b.url comme ItemUrl FROM Alireza \ Domain \ Identity \ Entities \ Menu u WHERE u.id =: id
Doctrine vous permet de limiter les résultats de la requête avec des filtres. Par exemple, vous pouvez modifier uniquement les informations de l'utilisateur connecté ou vous assurer que les données du client actuel ont été renvoyées de la base de données. Un filtre est une solution automatique pour mémoriser des conditions spécifiques pour toutes vos requêtes..
Doctrine fournit des limitations au niveau SQL. Il n'est donc pas nécessaire de conserver la clause dans plusieurs référentiels de votre projet. Cela améliore la sécurité et rend votre code plus facile à lire.
Regardons un exemple:
php / ** * @ManyToOne (targetEntity = "User") * @JoinColumn (name = "id_utilisateur", referenceColumnName = "id") ** / private $ user; Comme vous pouvez le voir dans l'entité Utilisateur, le résultat de JoinColumn est limité aux articles avec la condition de WHERE id_utilisateur =: id_utilisateur.
Pour configurer Doctrine, il existe un pont permettant la correspondance avec 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"
Doctrine n'a pas besoin de configuration de base de données et utilise la configuration actuelle de Laravel, mais si vous souhaitez la remplacer, vous devez modifier le fichier de configuration de Doctrine en Config / doctrine.php:
"php 'managers' => ['default' => ['dev' => env ('APP_DEBUG'), 'meta' => env ('DOCTRINE_METADATA', 'annotations'), 'connection' => env (' DB_CONNECTION ',' mysql '),' namespaces '=> [' App '],
"C'est tout ce qu'on peut en dire.
"Entité" fait référence à un objet qui a une identité distincte. Une entité doit avoir un identifiant spécifique unique dans tout le système, tel qu'un client ou un étudiant. Il y aurait d'autres objets, tels que les adresses électroniques, qui ne sont pas des entités, mais des objets de valeur.
Créons une entité postale App / Entité / Post.php:
"espace de noms php 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 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; "
Les propriétés de la classe doivent être identiques aux champs de la table de la base de données, ou vous pouvez les définir avec @Colum ("name" = "myfield") annotation.
Le référentiel permet à tout votre code d'utiliser des objets sans avoir besoin de 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é.
Maintenant il est temps de créer le Dépôt dans App / Repository / 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 prepareData ($ data) retour new Post ($ data);
"
La doctrine EntityManager fonctionne comme point d'accès pour la gestion complète de vos entités. Ensuite, créez le contrôleur 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.index') -> 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'); "La vue et le routage sont les mêmes que d'habitude. Je préfère créer mon propre validateur basé sur la classe validateur de Laravel. Voici le validateur App \ Validation \ PostValidator.php:
"Espace de noms php App \ Validation; use Validator;
class PostValidator public static function validate ($ input) $ rules = ['title' => 'Obligatoire | Min: 4 | Max: 80 | alpha_spaces', 'body' => 'Obligatoire',]; return Validator :: make ($ input, $ rules); "
Si vous n'avez pas encore travaillé avec Doctrine 2, j'espère que cet article a été intéressant et instructif. Laravel 5 n'utilise pas Doctrine, mais comme vous pouvez le constater, certains packages nous permettent de l'utiliser facilement avec Laravel. J'ai créé une application de blog simple avec Laravel 5 et Doctrine ORM, et j'espère que cela pourra vous aider à créer votre application souhaitée. Je me réjouis de vos commentaires.
