El patrón de repositorio en Laravel 5

El patrón de repositorio fue introducido por primera vez por Eric Evans en su libro de diseño impulsado por el dominio. El repositorio es, de hecho, el punto de entrada para el solicitud para acceder a la dominio capa.

En pocas palabras, el repositorio permite que todo su código utilice objetos sin tener que saber cómo se conservan los objetos. El repositorio contiene todo el conocimiento de la persistencia, incluida la asignación de tablas a objetos. Esto proporciona una vista más orientada a objetos de la capa de persistencia y hace que el código de mapeo sea más encapsulado..

La única manera de hacer que sus repositorios funcionen en Laravel (como un libro de diseño de Dominio dirigido por Dominio de Eric Evans real) es cambiar el ORM predeterminado del registro activo al asignador de datos. El mejor sustituto es Doctrina..

La Doctrina ORM

Doctrine es un ORM (mapeo objeto-relacional) que implementa el patrón del mapeador de datos y le permite hacer una separación clara de las reglas comerciales de la aplicación de la capa de persistencia de la base de datos. Doctrine usa DQL, en lugar de SQL. DQL le ofrece un lenguaje de consulta de objetos, lo que significa que en lugar de un término de consulta relacional tradicional, tendría consultas en el término de objeto.

Le permite escribir las consultas de la base de datos de una manera orientada a objetos y ayuda cuando necesita consultar la base de datos de una manera que no se puede lograr usando los métodos de repositorio predeterminados. En mi opinión, DQL es la forma más poderosa de mantenerse en contacto con su base de datos.

Doctrina vs. Elocuente

Las entidades de Doctrine son solo una clase simple de PHP simple y no agregan sobrecarga a ninguna herencia ORM. Doctrine administra sus múltiples solicitudes de consulta con la misma herencia sin llegar a la base de datos, lo que significa que el objeto de entidad existe para toda la solicitud.

La otra característica interesante de Doctrine es que, en lugar de migrar archivos para crear el esquema de la base de datos, la base de datos se crea automáticamente para reflejar los metadatos en las anotaciones de la entidad. Por otro lado, Eloquent es menos complicado y muy fácil de usar..

Una comparación completa entre estos dos requeriría un artículo separado. Como puedes ver, un objeto de Doctrine es más claro y más abstracto. Sin embargo, Doctrine solo se ajustará a proyectos específicos, por lo que a veces puede generarle gastos. Creo que depende del programador elegir el mejor ORM para la aplicación.

La aplicación de blog

Ahora es el momento de crear una aplicación de blog con Laravel. Primero, necesitamos configurar Doctrina. Hay un puente para permitir la coincidencia con la configuración existente de Laravel 5. Para instalar Doctrine 2 dentro de nuestro proyecto Laravel, ejecutamos el siguiente comando:

bash composer require laravel-doctrine / orm

Como es habitual, el paquete debe ser agregado a la app / config.php , como proveedor de servicios:

php LaravelDoctrine \ ORM \ DoctrineServiceProvider :: class,

El alias también debe estar configurado:

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

Finalmente, publicamos la configuración del paquete con:

proveedor artesano de bash php: publish --tag = "config"

Ahora hemos terminado aquí.

Las entidades son partes importantes de la aplicación. App \ Entities \ Post.php:

"php

namespace App \ Entity;

usa Doctrine \ ORM \ Mapping como 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; función pública __construct ($ input) $ this-> setTitle ($ input ['title']); $ this-> setBody ($ input ['body']);  función pública setId ($ id) return $ this-> id = $ id;  función pública getId () return $ this-> id;  función pública getTitle () return $ this-> title;  función pública setTitle ($ title) $ this-> title = $ title;  función pública getBody () return $ this-> body;  función pública setBody ($ body) $ this-> body = $ body;  "

Ahora es el momento de crear el Repositorio, que fue descrito anteriormente. Aplicación / Repositorios / PostRepo.php :

"php namespace App \ Repository;

usar App \ Entity \ Post; utilizar Doctrine \ ORM \ EntityManager; clase PostRepo

/ ** * @var string * / private $ class = 'App \ Entity \ Post'; / ** * @var EntityManager * / private $ em; función pública __construct (EntityManager $ em) $ this-> em = $ em;  public function create (Post $ post) $ this-> em-> persist ($ post); $ this-> em-> flush ();  actualización de la función pública (Post $ post, $ data) $ post-> setTitle ($ data ['title']); $ post-> setBody ($ data ['body']); $ this-> em-> persist ($ post); $ this-> em-> flush ();  función pública PostOfId ($ id) return $ this-> em-> getRepository ($ this-> class) -> findOneBy (['id' => $ id]);  eliminar función pública (Publicar $ post) $ this-> em-> remove ($ post); $ this-> em-> flush ();  / ** * create Post * @return Post * / private function perpareData ($ data) return new Post ($ data);  

"

El controlador: Aplicación / HTTP / Controladores / PostController.php :

"php namespace App \ Http \ Controllers; use App \ Repository \ PostRepo como repositorio; use App \ Validation \ PostValidator;

la clase PostController extiende Controller private $ repo;

función pública __construct (repo $ repo) $ this-> repo = $ repo;  public function edit ($ id = NULL) return View ('admin.edit') -> with (['data' => $ this-> repo-> postOfId ($ id)]);  public function editPost () $ all = Input :: all (); $ validate = PostValidator :: validate ($ all); if (! $ validate-> pass ()) 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', 'agregar éxito');  return redirect () -> back ();  public function retrieve () return View ('admin.index') -> with (['Data' => $ this-> repo-> retrieve ()]);  función pública delete () $ id = Input :: get ('id'); $ data = $ this-> repo-> postOfId ($ id); if (! is_null ($ data)) $ this-> repo-> delete ($ data); Session :: flash ('msg', 'Operation Success'); return redirect () -> back ();  else return redirect () -> back () -> withErrors ('operationFails');  "

Como ve, he usado el ayudante de Flash para administrar los mensajes (puede usar Laravel). Respecto al Validador, debo agregar que puedes crear el tuyo (como lo hago yo) o usar el valor predeterminado de Laravel, según tus preferencias..

Los archivos de vista son los mismos que de costumbre. En esta vista de muestra, el archivo parece recursos / vistas / admin / edit.blade.php :

"php

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

• !! $ error !!

@endforeach @endif