Il modello di deposito in Laravel 5

Il pattern di repository è stato introdotto per la prima volta da Eric Evans nel suo libro Domain-Driven Design. Il repository è, infatti, il punto di ingresso per il applicazione per accedere al dominio strato.

Per dirla semplicemente, il repository consente a tutto il codice di utilizzare oggetti senza dover sapere come vengono mantenuti gli oggetti. Il repository contiene tutta la conoscenza della persistenza, inclusa la mappatura dalle tabelle agli oggetti. Ciò fornisce una vista più orientata agli oggetti del livello di persistenza e rende il codice di mappatura più incapsulato.

L'unico modo per far funzionare i repository in Laravel (come un vero repository - il libro di Driven Design di Eric Evans) è quello di modificare l'ORM predefinito dal record attivo al data mapper. Il miglior sostituto è Doctrine.

The Doctrine ORM

Doctrine è un ORM (object-relational mapping) che implementa il pattern del data mapping e consente di separare in modo pulito le regole di business dell'applicazione dal livello di persistenza del database. Doctrine usa DQL, piuttosto che SQL. DQL ti porta linguaggio di query oggetto, il che significa che invece di un termine di query relazionale tradizionale, avresti query in termini di oggetto.

Permette di scrivere le query del database in modo orientato agli oggetti e aiuta quando è necessario interrogare il database in un modo che non può essere raggiunto utilizzando i metodi di repository predefiniti. Secondo me, DQL è il modo più efficace per restare in contatto con il tuo database.

Doctrine vs. Eloquent

Le entità Doctrine sono semplicemente una semplice classe PHP semplice e non aggiungono un sovraccarico a nessuna eredità ORM. Doctrine gestisce le tue molteplici richieste di query con la stessa ereditarietà senza colpire il database, ovvero l'oggetto entità esiste per l'intera richiesta.

L'altra caratteristica interessante di Doctrine è che invece di migrare i file per creare lo schema del database, il database viene creato automaticamente per riflettere i metadati nelle annotazioni delle entità. D'altra parte, Eloquent è meno complicato e molto facile da usare.

Un confronto completo tra questi due richiederebbe un articolo separato. Come puoi vedere, un oggetto Doctrine è più leggero e astratto. Tuttavia, Doctrine si adatterà solo a progetti specifici, quindi a volte potrebbe comportare un sovraccarico. Credo che dipenda dal programmatore scegliere il miglior ORM per l'app.

L'app per il blog

Ora è il momento di creare un'app blog con Laravel. Per prima cosa, dobbiamo impostare Doctrine. C'è un ponte per consentire la corrispondenza con la configurazione esistente di Laravel 5. Per installare Doctrine 2 nel nostro progetto Laravel, eseguiamo il seguente comando:

il compositore di bash richiede laravel-doctrine / orm

Come al solito, il pacchetto dovrebbe essere aggiunto al app / config.php , come fornitore di servizi:

php LaravelDoctrine \ ORM \ DoctrineServiceProvider :: class,

Anche l'alias deve essere configurato:

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

Infine, pubblichiamo la configurazione del pacchetto con:

fornitore bash php artisan: pubblicare --tag = "config"

Ora abbiamo finito qui.

Le entità sono parti importanti dell'app App \ Enti \ post.php:

"php

namespace App \ Entity;

usa Doctrine \ ORM \ Mapping come ORM;

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

/ ** * @ORM \ Column (type = "string") * / private $ title; / ** * @ORM \ Column (type = "text") * / private $ body; funzione pubblica __construct ($ input) $ this-> setTitle ($ input ['title']); $ This-> setBody ($ input [ 'corpo']);  setId funzione pubblica ($ id) return $ this-> id = $ id;  public function getId () return $ this-> id;  public function getTitle () return $ this-> title;  public function setTitle ($ title) $ this-> title = $ title;  funzione pubblica getBody () return $ this-> body;  funzione pubblica setBody ($ body) $ this-> body = $ body;  "

Ora è il momento di creare il deposito, che è stato descritto in precedenza. App / Repository / PostRepo.php :

"App dello spazio dei nomi php \ Repository;

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

/ ** * @var string * / private $ class = 'App \ Entity \ Post'; / ** * @var EntityManager * / private $ em; funzione pubblica __construct (EntityManager $ em) $ this-> em = $ em;  funzione pubblica create (post $ post) $ this-> em-> persist ($ post); $ This-> em-> flush ();  aggiornamento della funzione pubblica (post $ post, $ data) $ post-> setTitle ($ data ['title']); $ Post-> setBody ($ dati [ 'corpo']); $ This-> em-> persistono ($ post); $ This-> em-> flush ();  public function PostOfId ($ id) return $ this-> em-> getRepository ($ this-> class) -> findOneBy (['id' => $ id]);  public function delete (Post $ post) $ this-> em-> remove ($ post); $ This-> em-> flush ();  / ** * crea Post * @return Post * / private function perpareData ($ data) return new Post ($ data);  

"

Il controller: App / HTTP / Controller / PostController.php :

"php namespace App \ Http \ Controllers; usa App \ Repository \ PostRepo come repo; usa App \ Validation \ PostValidator;

classe PostController estende Controller private $ repo;

funzione pubblica __construct (repo $ repo) $ this-> repo = $ repo;  edit funzione pubblica ($ id = NULL) return View ('admin.edit') -> 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']); se (! 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', 'aggiungi successo');  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); se (! is_null ($ data)) $ this-> repo-> delete ($ data); Session :: flash ('msg', 'operazione Success'); return redirect () -> back ();  else return redirect () -> back () -> withErrors ('operationFails');  "

Come vedi, ho usato l'helper di Flash per gestire i messaggi (puoi usare quello di Laravel). Per quanto riguarda il Validator, dovrei aggiungere che puoi creare il tuo (come faccio io) o usare il default di Laravel, a seconda delle tue preferenze.

I file di visualizzazione sono gli stessi del solito. In questa vista di esempio, il file sembra Resources / views / admin / edit.blade.php :

"php

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

• !! $ errore !!

@endforeach @endif