Patrón de repositorio de Laravel

 

El patrón de repositorio puede ser muy útil para mantener su código un poco más limpio y legible. De hecho, no es necesario que utilice Laravel para utilizar este patrón de diseño en particular. Sin embargo, para este episodio, usaremos el framework php orientado a objetos Laravel para mostrar cómo el uso de repositorios hará que nuestros controladores sean un poco menos detallados, más sueltos y más fáciles de leer. ¡Saltemos!

---

Trabajar sin repositorios

¡El uso de repositorios no es obligatorio! Puede lograr muchas cosas excelentes en sus aplicaciones sin usar este patrón, sin embargo, con el tiempo, es posible que se arruine. Por ejemplo, al optar por no utilizar repositorios, su aplicación no se prueba fácilmente y el intercambio de implementaciones sería engorroso. Veamos un ejemplo.

Obtener listados de casas de una base de datos inmobiliaria

HousesController.php

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

<?php   class HousesController extends BaseController {     public function index() { $houses = House::all(); return View::make('houses.index', compact('houses')); }     public function create() { return View::make('houses.create'); }     public function show($id) { $house = House::find($id); return View::make('houses.show', compact('house')); } }

Este sería un código bastante típico para usar Eloquent para interactuar con la base de datos que contiene listados de casas en venta. Funcionará bien, pero el controlador ahora está estrechamente acoplado a Eloquent. En su lugar, podemos inyectar un repositorio para crear una versión poco acoplada del mismo código. Este acoplamiento flexible facilita el intercambio de implementaciones en un momento posterior.

---

Trabajar con repositorios

Hay una buena cantidad de pasos para completar todo el patrón del repositorio, pero una vez que lo revisa varias veces, se convierte en algo natural. Vamos a cubrir cada paso aquí.

• 1: Cree la carpeta del repositorio

Recientemente, analizamos una estructura de archivo de Laravel común que podría estar usando. Esto crea una carpeta en el appdirectorio para contener todos los archivos específicos de su dominio. Para este ejemplo, crearemos el repotutrepositoriesdentro de nuestra appcarpeta para contener nuestros archivos. Esto también configura nuestra estructura de espacio de nombres que tendremos que tener en cuenta para los archivos que creamos.

• 2: Crea tu interfaz

El siguiente paso es crear la interfaz que determinará el contrato que nuestro repositorio debe implementar. Esto solo establece los métodos que deben estar presentes en nuestro repositorio. Nuestra interfaz tendrá el siguiente aspecto. Tenga en cuenta el espacio de nombres y los métodos que usaremos.

HouseRepositoryInterface.php

1 2 3 4 5 6 7 8 9 10

<?php namespace repotutrepositories;   interface HouseRepositoryInterface { public function selectAll(); public function find($id); }

• 3: Crea tu repositorio

Ahora podemos crear el repositorio que hará todo el trabajo pesado por nosotros. Es en este archivo donde podemos poner todas nuestras consultas detalladas de Eloquent, sin importar cuán complejas se vuelvan. Cada método simplemente tiene un nombre personalizado para que en nuestro controlador, podamos escribir un código muy corto para obtener el resultado deseado. Nuevamente observe el espacio de nombres y la use House;declaración.

DbHouseRepository.php

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

<?php namespace repotutrepositories;   use House;   class DbHouseRepository implements HouseRepositoryInterface { public function selectAll() { return House::all(); } public function find($id) { return House::find($id); } }

• 4: Crear proveedor de servicios de backend

Para nuestro controlador, vamos a escribir hint una interfaz. Vamos a hacer una inyección de dependencias, pero básicamente a través de una interfaz. Lo que esto significa es que necesitamos registrar la interfaz con Laravel para que sepa qué implementación de nuestra interfaz queremos usar. Primero usaremos una implementación de Eloquent, pero luego pasaremos a una implementación basada en archivos para mostrar cómo podemos intercambiar implementaciones fácilmente usando una interfaz. Colocamos este proveedor de servicios en el mismo espacio de nombres que nuestros otros archivos hasta ahora.

BackendServiceProvider.php

1 2 3 4 5 6 7 8 9 10 11 12

<?php namespace repotutrepositories;   use IlluminateSupportServiceProvider;   class BackendServiceProvider extends ServiceProvider { public function register() { $this->app->bind('repotutrepositoriesHouseRepositoryInterface', 'repotutrepositoriesDbHouseRepository'); } }

Básicamente, este código dice que, cuando vea la sugerencia del tipo de controlador HouseRepositoryInterface, sabemos que desea utilizar el DbHouseRepository.

• 5: Actualice la matriz de proveedores

Ahora que hemos creado un nuevo proveedor de servicios, debemos agregarlo a la providersmatriz que contiene app/config/app.php. Puede verse algo así una vez que esté completo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

'providers' => array(   'IlluminateFoundationProvidersArtisanServiceProvider', 'IlluminateAuthAuthServiceProvider', 'IlluminateCacheCacheServiceProvider', 'IlluminateSessionCommandsServiceProvider', 'IlluminateFoundationProvidersConsoleSupportServiceProvider', 'IlluminateRoutingControllerServiceProvider', 'IlluminateCookieCookieServiceProvider', 'IlluminateDatabaseDatabaseServiceProvider', 'IlluminateEncryptionEncryptionServiceProvider', 'IlluminateFilesystemFilesystemServiceProvider', 'IlluminateHashingHashServiceProvider', 'IlluminateHtmlHtmlServiceProvider', 'IlluminateLogLogServiceProvider', 'IlluminateMailMailServiceProvider', 'IlluminateDatabaseMigrationServiceProvider', 'IlluminatePaginationPaginationServiceProvider', 'IlluminateQueueQueueServiceProvider', 'IlluminateRedisRedisServiceProvider', 'IlluminateRemoteRemoteServiceProvider', 'IlluminateAuthRemindersReminderServiceProvider', 'IlluminateDatabaseSeedServiceProvider', 'IlluminateSessionSessionServiceProvider', 'IlluminateTranslationTranslationServiceProvider', 'IlluminateValidationValidationServiceProvider', 'IlluminateViewViewServiceProvider', 'IlluminateWorkbenchWorkbenchServiceProvider', 'repotutrepositoriesBackendServiceProvider'   ),

• 6: Actualice su controlador para la inyección de dependencia

Tenemos la mayor parte del trabajo preliminar en su lugar. Ahora podemos actualizar el controlador para facilitar la inyección de una implementación de HouseRepositoryInterface. Esto nos permitirá eliminar todas las llamadas a Eloquent directamente en el controlador y reemplazarlas con llamadas simples a métodos personalizados. Nuestro controlador actualizado podría verse así:

HousesController.php

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

<?php   use repotutrepositoriesHouseRepositoryInterface;   class HousesController extends BaseController { public function __construct(HouseRepositoryInterface $house) { $this->house = $house; }     public function index() { $houses = $this->house->selectAll();   return View::make('houses.index', compact('houses')); }     public function create() { return View::make('houses.create'); }     public function show($id) { $house = $this->house->find($id); return View::make('houses.show', compact('house'));   } }

• 7: Confirme que las rutas sean correctas

Para este ejemplo, simplemente configuramos un recurso de ruta como este:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

<?php   /* |-------------------------------------------------------------------------- | Application Routes |-------------------------------------------------------------------------- | | Here is where you can register all of the routes for an application. | It's a breeze. Simply tell Laravel the URIs it should respond to | and give it the Closure to execute when that URI is requested. | */   Route::resource('houses', 'HousesController');

• 8: actualiza composer.json

Si aún no lo ha hecho, asegúrese de que el espacio de nombres al que hacemos referencia esté en su composer.json. Tenga en cuenta la adición de "psr-4":{"repotut\": "app/repotut" }que le dice al compositor que cargue automáticamente las clases dentro del repotutespacio de nombres.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

{ "name": "laravel/laravel", "description": "The Laravel Framework.", "keywords": ["framework", "laravel"], "license": "MIT", "require": { "laravel/framework": "4.2.*" }, "autoload": { "classmap": [ "app/commands", "app/controllers", "app/models", "app/database/migrations", "app/database/seeds", "app/tests/TestCase.php" ],                              "psr-4":{                      "repotut\": "app/repotut"                 } }, "scripts": { "post-install-cmd": [ "php artisan clear-compiled", "php artisan optimize" ], "post-update-cmd": [ "php artisan clear-compiled", "php artisan optimize" ], "post-create-project-cmd": [ "php artisan key:generate" ] }, "config": { "preferred-install": "dist" }, "minimum-stability": "stable" }

¡No olvide ejecutar composer dumpdespués de la actualización composer.json!

---

¡Guau! Buen compañero de trabajo, probémoslo en el navegador. Podemos visitarhttp://localhost/repotut/public/housesy podemos ver que tenemos 3 casas en venta, cada una de un color diferente.

---

Implementaciones fáciles de cambiar

Digamos que en el futuro decide que Eloquent no es la forma en que desea manejar el almacenamiento de datos con su aplicación. ¡No hay problema! Como ya preparó el trabajo preliminar para el uso de una interfaz, puede crear un nuevo repositorio y cambiar el proveedor de servicios. Veamos cómo podemos intercambiar implementaciones.

• 1: Crea un nuevo repositorio

Solo usaremos un ejemplo rápido aquí. Supongamos que se trata de una clase de sistema de archivos completa que proporciona almacenamiento de datos a través de archivos planos. En nuestro caso, solo pondremos algo de lógica simple para probar las implementaciones de intercambio. Tenga en cuenta que esta clase implementa exactamente los mismos métodos que la versión Eloquent que probamos antes.

FileHouseRepository.php

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

<?php namespace repotutrepositories;   class FileHouseRepository implements HouseRepositoryInterface { public function selectAll() { $houses = new stdClass; $house1 = new stdClass; $house1->color = 'Olive'; $house2 = new stdClass; $house2->color = 'Yellow'; $house3 = new stdClass; $house3->color = 'Brown'; $houses = array($house1,$house2,$house3); return $houses; } public function find($id) { return 'Here is a single house listing, again using the file system'; } }

• 2: Proveedor de servicios de actualización

Ahora en el Proveedor de servicios, ¡todo lo que tenemos que hacer es cambiar una sola línea de código! Simplemente le decimos a Laravel que ahora, cuando vea el HouseRepositoryInterface, usará FileHouseRepository en lugar de DbHouseRepository.

1 2 3 4 5 6 7 8 9 10 11 12

<?php namespace repotutrepositories;   use IlluminateSupportServiceProvider;   class BackendServiceProvider extends ServiceProvider { public function register() { $this->app->bind('repotutrepositoriesHouseRepositoryInterface', 'repotutrepositoriesFileHouseRepository'); } }

Cuando lo probamos en el navegador http://localhost/repotut/public/houses, podemos ver que la nueva implementación ha surtido efecto, ¡genial!

Conclusión de repositorios

Como puede ver, parece que hay muchos pasos para que los repositorios funcionen en su aplicación. Hay algunos pasos involucrados, sin duda alguna. Sin embargo, si va a ser responsable de mantener un fragmento de código a largo plazo, obtendrá los beneficios de tomarse el tiempo para diseñar correctamente su aplicación al principio. Considérelo una forma de gratificación tardía, que en la actualidad parece un arte olvidado.