Un Middleware de Laravel es una capa que se ejecuta entre la solicitud HTTP del usuario y la respuesta de la aplicación.

Su función principal es interceptar y procesar una petición antes de que llegue al controlador, aunque también puede actuar sobre la respuesta antes de enviarla al navegador.

De forma simplificada, el flujo sería:

Usuario
   ↓
Solicitud HTTP
   ↓
Middleware
   ↓
Controlador
   ↓
Respuesta
   ↓
Middleware
   ↓
Usuario

Esto permite implementar lógica que debe aplicarse a una o varias rutas sin tener que repetir el mismo código dentro de cada controlador.

Entre los usos más habituales encontramos:

• Comprobar si el usuario está autenticado.
• Verificar permisos o roles.
• Restringir el acceso a determinadas rutas.
• Comprobar el estado de una cuenta.
• Registrar solicitudes HTTP.
• Añadir o modificar cabeceras.
• Aplicar reglas de seguridad.
• Limitar determinadas operaciones.
• Comprobar el origen de una petición.
• Ejecutar lógica antes o después de un controlador.

Por ejemplo, podemos crear un Middleware que permita acceder a /admin únicamente a usuarios con permisos de administrador.

Un Middleware recibe una solicitud (Request) y una función $next.

La estructura básica es similar a esta:

public function handle(Request $request, Closure $next)
{
    // Lógica antes del controlador

    $response = $next($request);

    // Lógica después del controlador

    return $response;
}

La parte más importante es:

$next($request)

Esta instrucción permite que la solicitud continúe hacia el siguiente Middleware o hacia el controlador.

Podemos imaginar el Middleware como una puerta:

Request
   ↓
┌─────────────────┐
│    Middleware   │
│                 │
│ ¿Puede pasar?   │
└────────┬────────┘
         │
     Sí  ↓
   Controller
         │
         ↓
      Response

Si el Middleware determina que la petición no debe continuar, puede devolver una respuesta directamente.

Laravel proporciona Artisan para generar Middleware automáticamente.

Abre la terminal dentro de tu proyecto y ejecuta:

php artisan make:middleware CheckAge

Laravel creará un archivo similar a:

app/
└── Http/
    └── Middleware/
        └── CheckAge.php

El archivo generado tendrá una estructura parecida a:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class CheckAge
{
    public function handle(Request $request, Closure $next): Response
    {
        return $next($request);
    }
}

A partir de aquí podemos añadir nuestra propia lógica.

Supongamos que tenemos una sección de nuestra aplicación que únicamente pueden visitar usuarios mayores de 18 años.

Podemos crear un Middleware:

php artisan make:middleware CheckAge

Después modificamos el método handle():

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class CheckAge
{
    public function handle(Request $request, Closure $next): Response
    {
        if ($request->user()->age < 18) {
            abort(403, 'Debes ser mayor de edad.');
        }

        return $next($request);
    }
}

En este ejemplo:

1. Laravel recibe la petición.
2. El Middleware obtiene el usuario autenticado.
3. Comprueba su edad.
4. Si tiene menos de 18 años, devuelve un error 403.
5. Si tiene 18 años o más, la petición continúa.

La llamada:

return $next($request);

es la que permite continuar con el procesamiento normal de la solicitud.

Importante: si la ruta puede ser visitada por usuarios no autenticados, conviene utilizar primero el Middleware auth o comprobar que $request->user() no sea null.

Una vez creado nuestro Middleware, podemos utilizarlo en las rutas.

En las versiones actuales de Laravel, una forma habitual de registrar un alias de Middleware es hacerlo en bootstrap/app.php.

Por ejemplo:

use App\Http\Middleware\CheckAge;
use Illuminate\Foundation\Configuration\Middleware;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->alias([
            'check.age' => CheckAge::class,
        ]);
    })
    ->create();

Después podemos utilizar el alias en nuestras rutas:

use Illuminate\Support\Facades\Route;

Route::get('/contenido-adulto', function () {
    return 'Contenido para mayores de edad';
})->middleware('check.age');

Ahora, cada vez que alguien acceda a:

/contenido-adulto

Laravel ejecutará primero CheckAge.

Uno de los usos más frecuentes de Middleware es comprobar si un usuario ha iniciado sesión.

Laravel incluye el Middleware auth, por lo que podemos proteger una ruta fácilmente:

Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware('auth');

Si el usuario no está autenticado, Laravel impedirá que acceda directamente a la ruta.

También podemos combinar Middleware:

Route::get('/admin', function () {
    return view('admin.dashboard');
})->middleware(['auth', 'check.age']);

En este caso, Laravel ejecutará ambos Middleware.

Otro ejemplo muy común es restringir determinadas páginas a usuarios administradores.

Podemos crear:

php artisan make:middleware AdminMiddleware

Y escribir:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class AdminMiddleware
{
    public function handle(Request $request, Closure $next): Response
    {
        if (!$request->user() || $request->user()->role !== 'admin') {
            abort(403, 'No tienes permisos para acceder a esta sección.');
        }

        return $next($request);
    }
}

Después registramos el alias:

$middleware->alias([
    'admin' => \App\Http\Middleware\AdminMiddleware::class,
]);

Y protegemos nuestra ruta:

Route::get('/admin', function () {
    return view('admin.dashboard');
})->middleware(['auth', 'admin']);

De esta forma:

• Un usuario no autenticado no puede acceder.
• Un usuario autenticado sin rol admin recibe un error 403.
• Un administrador puede acceder normalmente.

Los Middleware de Laravel también pueden recibir parámetros.

Esto resulta especialmente útil cuando queremos reutilizar el mismo Middleware con diferentes valores.

Por ejemplo:

Route::get('/admin', function () {
    return 'Panel de administración';
})->middleware('role:admin');

Podemos crear un Middleware:

php artisan make:middleware CheckRole

Y utilizar un segundo parámetro en handle():

public function handle(
    Request $request,
    Closure $next,
    string $role
): Response {
    if (!$request->user() || $request->user()->role !== $role) {
        abort(403);
    }

    return $next($request);
}

Ahora podemos reutilizar el mismo Middleware:

Route::get('/admin', fn () => 'Administración')
    ->middleware('role:admin');

Route::get('/editor', fn () => 'Editor')
    ->middleware('role:editor');

Esto evita crear un Middleware diferente para cada tipo de usuario.

Una característica interesante de los Middleware es que podemos ejecutar código antes y después del controlador.

Por ejemplo:

public function handle(Request $request, Closure $next): Response
{
    // Antes del controlador
    logger()->info('Antes del controlador');

    $response = $next($request);

    // Después del controlador
    logger()->info('Después del controlador');

    return $response;
}

El flujo sería:

Middleware
    ↓
"Antes del controlador"
    ↓
$next($request)
    ↓
Controller
    ↓
Response
    ↓
"Después del controlador"
    ↓
Usuario

Esta característica resulta especialmente útil cuando necesitamos modificar o inspeccionar la respuesta.

Laravel permite utilizar Middleware de diferentes maneras.

Middleware global

Un Middleware global se ejecuta para todas las solicitudes HTTP que pasan por la aplicación.

Es apropiado para tareas que realmente deben aplicarse de forma general.

Por ejemplo:

• Procesamiento de cabeceras.
• Determinadas comprobaciones de seguridad.
• Registro global de solicitudes.

Middleware de ruta

Un Middleware de ruta se aplica únicamente a determinadas rutas.

Por ejemplo:

Route::get('/perfil', function () {
    return view('profile');
})->middleware('auth');

En este caso, auth únicamente se ejecuta para la ruta correspondiente.

En general, es recomendable utilizar Middleware de ruta cuando la lógica no necesita ejecutarse en toda la aplicación

Si varias rutas necesitan las mismas restricciones, podemos utilizar un grupo:

Route::middleware(['auth', 'admin'])->group(function () {

    Route::get('/admin', function () {
        return view('admin.dashboard');
    });

    Route::get('/admin/users', function () {
        return view('admin.users');
    });

    Route::get('/admin/settings', function () {
        return view('admin.settings');
    });

});

Esto evita repetir:

->middleware(['auth', 'admin'])

en cada ruta.

Es una solución especialmente útil para paneles de administración y APIs.

También podemos asignar Middleware desde un controlador.

Por ejemplo:

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

De esta forma, las acciones del controlador quedan protegidas por el Middleware indicado.

Dependiendo de la versión de Laravel y del estilo de aplicación utilizado, también puedes preferir definir Middleware directamente en las rutas para mantener más visible la configuración del acceso.

Los Middleware son especialmente importantes cuando desarrollamos una API.

Por ejemplo, podemos proteger nuestras rutas con autenticación:

Route::middleware('auth:sanctum')->group(function () {

    Route::get('/profile', function (Request $request) {
        return $request->user();
    });

    Route::get('/orders', function () {
        return 'Lista de pedidos';
    });

});

En este caso, las rutas solamente estarán disponibles para usuarios autenticados mediante el mecanismo configurado.

También podemos combinar diferentes Middleware:

Route::middleware([
    'auth:sanctum',
    'admin'
])->group(function () {

    Route::get('/users', function () {
        return User::all();
    });

});

Los Middleware personalizados suelen encontrarse en:

app/Http/Middleware

Por ejemplo:

app/
└── Http/
    └── Middleware/
        ├── AdminMiddleware.php
        ├── CheckAge.php
        └── CheckRole.php

Mientras que la configuración de Middleware de la aplicación moderna de Laravel se realiza principalmente desde:

bootstrap/app.php

Esto es importante porque la configuración ha cambiado respecto a versiones antiguas de Laravel.

Para mantener un proyecto Laravel limpio y mantenible, sigue estas recomendaciones:

• Mantén cada Middleware enfocado en una responsabilidad.
• Utiliza nombres descriptivos.
• Reutiliza Middleware mediante parámetros cuando sea apropiado.
• Evita introducir lógica de negocio compleja.
• Utiliza auth para comprobar autenticación.
• Devuelve respuestas HTTP apropiadas (401, 403, etc.).
• Agrupa rutas que compartan las mismas reglas.
• Documenta Middleware especialmente importantes para la seguridad.
• Escribe tests para reglas de autorización críticas.
• No utilices Middleware como sustituto de Policies o Gates cuando la lógica corresponde específicamente a autorización de recursos.

¿Qué es un Middleware en Laravel?

Un Middleware es una capa que intercepta las solicitudes HTTP antes de que lleguen al controlador y que también puede procesar la respuesta antes de enviarla al usuario.

¿Cómo creo un Middleware en Laravel?

Puedes utilizar Artisan:

php artisan make:middleware MiMiddleware

Laravel generará el archivo correspondiente dentro de app/Http/Middleware.

¿Cómo asigno un Middleware a una ruta?

Puedes utilizar el método middleware():

Route::get('/dashboard', fn () => 'Dashboard')
    ->middleware('auth');

¿Puedo utilizar varios Middleware?

Sí. Puedes pasar varios Middleware:

->middleware(['auth', 'admin']);

También puedes utilizarlos en grupos de rutas.

¿Para qué sirve $next($request)?

Permite que la petición continúe hacia el siguiente Middleware o hacia el controlador.

return $next($request);

Es una de las partes fundamentales del funcionamiento de un Middleware.