¿Qué es el middleware en Laravel 5?

Entonces, ¿qué es Middleware en Laravel 5? Como sabemos, Laravel cinco en realidad se envía con una implementación de Middleware en el uso de la configuración de un servicio de autenticación como discutimos en nuestra introducción a Laravel 5. Una vez que comience a investigar cómo funciona el middleware en Laravel 5, lo encontrará para ser un recurso invaluable para obtener un fantástico nivel de control sobre su aplicación. De forma predeterminada, Laravel 5 usa middleware para manejar cosas como mantenimiento, cifrado de cookies, manejo de sesiones, autenticación, protección CSRF y más. Al observarlos en el código, podemos aprender a crear nuestro propio middleware para cualquier propósito que podamos necesitar.

¿Qué es el middleware?

---

Comience con la documentación oficial

Por supuesto, el mejor lugar para aprender qué es el middleware en Laravel 5 es simplemente comenzar primero con la documentación oficial . La documentación es fantástica, y si tiene problemas, siempre puede ver el video gratuito de laracast que cubre el middleware. De hecho, hay algunos recursos excelentes adicionales en la comunidad para aprender más sobre middleware, uno de ellos en codeheaps y, finalmente, la excelente explicación de Matt Stauffer .

---

Entonces, ¿qué son los middlewares?

En Laravel, Middleware es el mecanismo para aplicar cualquier tipo de filtrado que pueda necesitar a las solicitudes HTTP a su aplicación. Con su aplicación viviendo en Internet, es una apuesta justa que casi toda la interacción con ella será a través de solicitudes HTTP entrantes. Por lo tanto, es importante poder aprovechar esas solicitudes y tomar medidas o filtrar según sea necesario. Este nuevo enfoque de middleware para el manejo es realmente intuitivo. Una forma fácil de pensar en el middleware es como la de una cebolla, donde cada capa es un filtro específico, por así decirlo, en la solicitud HTTP. Así es como Jeffrey Way lo explica en su video, y la publicación de Richard Bagshaws incluso presenta una bonita imagen de una cebolla para recalcar ese punto. Entonces, para omitir la verborrea y simplemente responder a la pregunta,Laravel Middlware es un medio para filtrar las solicitudes HTTP a su aplicación .

---

¿Para qué usaría middleware?

De hecho, esa es una buena pregunta, joven viajero. De hecho, ya hizo uso del middleware de Laravel tan pronto como lo instaló y probó la aplicación esqueleto local provista. El uso más obvio es el de la autenticación de usuario. Cuando instalas Laravel, la instalación básica proporciona una forma de registrarte en una aplicación fantasma y luego te redirige a la página de inicio, o al panel de control, si quieres, de la aplicación. Si eres un invitado, no puedes llegar a esta área sensible. Todo esto se maneja a través de Middleware de una manera simple, limpia y transparente. En última instancia, puede usar middleware como desee. La documentación señala el uso de middleware para quizás configurar encabezados en respuestas HTTP, o para usar con solicitudes de registro a su aplicación.

---

¿Como funciona?

Cuando comienzas con Laravel, aprendes rápidamente a buscar en el routes.phparchivo para obtener una descripción general rápida de una aplicación y aprender cómo y dónde se pueden realizar solicitudes. Cuando necesite obtener esa misma idea o una vista de alto nivel de Middleware en la aplicación, se apunta directamente al Kernel.phparchivo incluido que se encuentra junto al routes.phparchivo. Echemos un vistazo, ¿de acuerdo?

Fuente de la aplicación \ Http \ Kernel.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

<?php namespace App\Http;   use Illuminate\Foundation\Http\Kernel as HttpKernel;   class Kernel extends HttpKernel {   /** * The application's global HTTP middleware stack. * * @var array */ protected $middleware = [ 'Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode', 'Illuminate\Cookie\Middleware\EncryptCookies', 'Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse', 'Illuminate\Session\Middleware\StartSession', 'Illuminate\View\Middleware\ShareErrorsFromSession', 'App\Http\Middleware\VerifyCsrfToken', ];   /** * The application's route middleware. * * @var array */ protected $routeMiddleware = [ 'auth' => 'App\Http\Middleware\Authenticate', 'auth.basic' => 'Illuminate\Auth\Middleware\AuthenticateWithBasicAuth', 'guest' => 'App\Http\Middleware\RedirectIfAuthenticated', ];   }

Excelente. Como podemos ver, hay dos instancias del middleware, el middleware de la aplicación representado porprotected $middlewarey el middleware de ruta representado porprotected $routeMiddleware. Nos mantendremos alejados de la primera instancia, ya que Laravel mismo los está utilizando para hacer todo el trabajo preliminar por nosotros en términos de tipo de plataforma de nivel de aplicación. Este primer middleware es una instancia global de middleware, y todo lo que contenga se ejecutará en cada solicitud HTTP a la aplicación. Sin embargo, el middleware de ruta se personaliza fácilmente, y aquí es donde jugaremos con algunas cosas.

---

La importancia de Kernel.php

Es en el Kernel.phparchivo donde se registra el middleware. Este enfoque es común en Laravel, ya que casi todo está registrado de alguna manera para que la aplicación pueda hacer uso de él. Esto nos da una manera conveniente de referirnos a la lógica de la aplicación usando una notación abreviada, es decir, esta 'clave' usa esa 'clase' . Un ejemplo de esto es la combinación authy App\Http\Middleware\Authenticateenumerada anteriormente. Laravel hace uso de esta combinación en HomeController.php como se muestra aquí.

Fuente de la aplicación \ Http \ Controllers \ HomeController.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 36

<?php namespace App\Http\Controllers;   class HomeController extends Controller {   /* |-------------------------------------------------------------------------- | Home Controller |-------------------------------------------------------------------------- | | This controller renders your application's "dashboard" for users that | are authenticated. Of course, you are free to change or remove the | controller as you wish. It is just here to get your app started! | */   /** * Create a new controller instance. * * @return void */ public function __construct() { $this->middleware('auth'); }   /** * Show the application dashboard to the user. * * @return Response */ public function index() { return view('home'); }   }

Póngase su gorra de detective y observe ese $this->middleware('auth');fragmento dentro del constructor. Hmmmm. Ahora, acabamos de ver que hay una authclave que hace referencia App\Http\Middleware\Authenticateen el protegido $routeMiddlewarede Kernel.php. Eso debe significar que todo lo que esté en App\Http\Middleware\Authenticatese ejecutará en todas las solicitudes en las que esté adjunto. De hecho, dado que ese método se aplica al constructor, cualquier otro método en este controlador tendrá esta lógica aplicada. Aquí es donde empiezas a enamorarte del middleware en Laravel. Con una colocación de código simple y conveniente, tiene efectos de gran alcance en la lógica de su aplicación. Entonces, veamos qué hay en ese archivo de autenticación:

Fuente de la aplicación \ Http \ Middleware \ Authenticate.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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

<?php namespace App\Http\Middleware;   use Closure; use Illuminate\Contracts\Auth\Guard;   class Authenticate {   /** * The Guard implementation. * * @var Guard */ protected $auth;   /** * Create a new filter instance. * * @param  Guard  $auth * @return void */ public function __construct(Guard $auth) { $this->auth = $auth; }   /** * Handle an incoming request. * * @param  \Illuminate\Http\Request  $request * @param  \Closure  $next * @return mixed */ public function handle($request, Closure $next) { if ($this->auth->guest()) { if ($request->ajax()) { return response('Unauthorized.', 401); } else { return redirect()->guest('auth/login'); } }   return $next($request); }   }

Aquí es donde comenzamos a examinar el concepto de capas de una cebolla. Podemos ver que el método aquí es handle. handlees el método que va a manejar adecuadamente la solicitud HTTP entrante. Dentro de este método, sucederá algo de lógica y se tomarán decisiones sobre cómo manejar esa solicitud. Cuando terminamos con eso, simplemente devolvemos la solicitud a la aplicación y se puede procesar desde allí. Incluso puede terminar golpeando otro middleware diferente y manejarse de una manera diferente. Cada vez que se maneja la solicitud, ha pasado por una capa más de la cebolla. En el ejemplo aquí de la instalación predeterminada de laravel, tenemos un middleware que mira la solicitud HTTP entrante, determina si el usuario está autenticado y, si no lo está, es redirigido a la página de inicio de sesión. No se confunda con la mención de $ auth en este archivo. Esto simplemente se refiere a la instancia deGuardque se está escribiendo y pasando al constructor. Esto no se refiere a la authclave en Kernel.php. De hecho, podríamos nombrar esta instancia aquí como queramos y funcionará de la misma manera. ¿Necesitas una prueba? Este archivo de autenticación con un $ auth renombrado todavía funciona.

Todavía funciona

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 41 42 43 44 45 46 47 48 49 50

<?php namespace App\Http\Middleware;   use Closure; use Illuminate\Contracts\Auth\Guard;   class Authenticate {   /** * The Guard implementation. * * @var Guard */ protected $yabadabado;   /** * Create a new filter instance. * * @param  Guard  $yabadabado * @return void */ public function __construct(Guard $yabadabado) { $this->yabadabado = $yabadabado; }   /** * Handle an incoming request. * * @param  \Illuminate\Http\Request  $request * @param  \Closure  $next * @return mixed */ public function handle($request, Closure $next) { if ($this->yabadabado->guest()) { if ($request->ajax()) { return response('Unauthorized.', 401); } else { return redirect()->guest('auth/login'); } }   return $next($request); }   }

Por supuesto, nunca haría esto, solo lo usamos con fines de demostración para investigar cómo se relacionan el registro de middleware y la implementación real. En resumen, examinemos el flujo de esta instancia de middleware.

1. Se realiza una solicitud HTTP entrante a la /homeruta.
2. Route::get('home', 'HomeController@index'); dirige esto al controlador adecuado.
3. HomeController.php tiene este fragmento en su constructor
   
   1 2 3 4

   public function __construct() { $this->middleware('auth'); }

   Por lo tanto, antes de que se ejecute cualquier método, el middleware actuará primero en esta solicitud HTTP.

4. Determine a qué se $this->middleware('auth');refiere.
5. Verifique Kernel.phpesta respuesta.
   1 2	protected $routeMiddleware = [ 'auth' => 'App\Http\Middleware\Authenticate',

   nos muestra que la authclave hará uso del middleware ubicado enApp\Http\Middleware\Authenticate

6. Al examinar este archivo anterior, sabemos que si el usuario es un invitado, será redirigido a la página de inicio de sesión. De lo contrario, deben estar autenticados y se les permite seguir adelante.
7. Si el usuario está autenticado, su solicitud HTTP ahora pasará al siguiente método del HomeController
   1 2 3 4

   public function index() { return view('home'); }

   y se cargará su página de inicio o panel de control.

¡Frio! Esto ahora tiene mucho sentido, ¡así que sigamos adelante y creemos nuestra propia implementación de un middleware ahora!

---

Cree su propio middleware

Como la mayoría de las cosas en Laravel, puede hacer uso de Artisan , la utilidad de línea de comando para crear middleware como puede hacerlo para controladores, modelos y más. Supongamos que tiene una sección de la aplicación solo para administradores a la que solo desea que un administrador pueda acceder. Es un gran candidato para middleware.

1. Cree nuestro middleware

php artisan make:middleware AdminMiddleware
Middleware creado con éxito.

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

<?php namespace App\Http\Middleware;   use Closure;   class AdminMiddleware {   /** * Handle an incoming request. * * @param  \Illuminate\Http\Request  $request * @param  \Closure  $next * @return mixed */ public function handle($request, Closure $next) { return $next($request); }   }

Esto nos da un buen punto de partida para crear nuestro propio Middleware. Agreguemos nuestra lógica para proteger nuestra área de administrador.

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

<?php namespace App\Http\Middleware;   use Closure; use Illuminate\Contracts\Auth\Guard;   class AdminMiddleware {     protected $auth;       public function __construct(Guard $auth)     {         $this->auth = $auth;     }       public function handle($request, Closure $next)     {         if ($this->auth->guest()) {               // if they are a guest, go to home page             return \Redirect::to('/');           } elseif ($this->auth->user()->name != 'Admin') {               // if they are logged in and the user is not Admin, go to home page             return \Redirect::to('/');         }           return $next($request);     } }

En este ejemplo, simplemente creamos nuestra propia implementación de un filtro de tipo de autenticación que podemos usar en algo como un AdminController dedicado que manejaría solo el back-end de una aplicación web. En este middleware, hacemos una simple verificación para ver si el usuario está conectado y también nos aseguramos de que sea el administrador. Si ambos se retiran, los dejamos entrar en el área de Administrador del sitio.

2. Registre nuestro middleware

Queremos identificar nuestro middleware recién creado de manera simple isadmin, por lo que lo agregaremos a nuestro Kernel.phpasí:

1 2 3 4 5 6

protected $routeMiddleware = [      'auth' => 'App\Http\Middleware\Authenticate',              'isadmin' => 'App\Http\Middleware\AdminMiddleware',      'auth.basic' => 'Illuminate\Auth\Middleware\AuthenticateWithBasicAuth',      'guest' => 'App\Http\Middleware\RedirectIfAuthenticated', ];

Tenga en cuenta que agregamos 'isadmin' => 'App\Http\Middleware\AdminMiddleware'a nuestra matriz de middleware de ruta.

3. Aplicar nuestro nuevo middlware al área de administrador

Fuente de la aplicación \ Http \ Controllers \ AdminController.php

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

<?php namespace App\Http\Controllers;   use App\Http\Requests; use App\Http\Controllers\Controller; use Illuminate\Http\Request;   class AdminController extends Controller {       public function __construct()     {         $this->middleware('isadmin');     }       public function index()     {         return view('admin.index');     } }

Ahora, a menos que un usuario sea el administrador, no podrá acceder al área de administrador de la aplicación.

En resumen

• A partir de Laravel 5, los archivos de middleware viven en app\Http\Middleware
• Para ver rápidamente qué middleware está registrado y en uso en su aplicación, verifique el Kernel.phparchivo ubicado enapp\Http
• Para crear su propio middleware, utilice php artisan make:middleware YourMiddleware
• Para registrar su middleware para rutas, regístrese en $routeMiddleware
• Para registrar su middleware a nivel mundial, regístrese en $middleware
• Para adjuntar un middleware a todo su controlador, especifique el middleware en su constructor.
• Para usar middleware solo en una ruta específica, especifíquelo en la matriz de opciones de ruta en su routes.phparchivo.

Eso es todo por ahora, ¡feliz filtrado HTTP!