une fonction qui permet de faire des traitement sépécifique avant l'exécution de la fonction associé à une route

  Route:get("/ajouter")  ----->Middleware("UnMiddleware")---->fonction associé

Exemple Authenfication

Route::get("/test",[TestController::class,'sayHello'])->name("testroute")->middleware('auth');

le middleware auth s'éxécute avant la fonction sayHello associé à la route /test si l'utilisateur est connecté le middleware laisse passé à l'exécution de la fonction sayHello sinon il affiche la page d'authentification

Syntaxe

namespace App\Http\Middleware;

use Closure;

class UnMiddleware
{
    public function handle($request, Closure $next)
    {
      //les traitements 
      //...
      //si tous est bien laisse passer
         return $next($request);
    }
}

$request: Représente l'objet de la requête HTTP entrante.( paramètres, les en-têtes, etc.)
$next: permet d'exécuter le middleware suivant (middleware('Middleware1')->middleware('Middleware2')->... ou la fonction associé à route

Exemple

Ecrire un middleware qui permet de detecter la langue d'un visiteur

Création du middleware

  php artisan make:middelware LangueDetector

Http/Middleware/LangueDetector

  <?php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class LangueDetector
{
   
    public function handle(Request $request, Closure $next): Response
    {
        //récupérer la langue du visituer
        $lang=$request->getDefaultLocale();

        // Définit la langue de l'application pour ce visiteur
        app()->setLocale($lang); 
        // ou Stocke la langue dans la session
        session(['langueDetected' => $lang]); 
       
        return $next($request);
    }
}

Ajouter le middleware dans Kernel.php

Afin de rendre le middleware crée(LangueDetector) visible par la fonction middleware("nomMiddleware") on doit le déclarer dans le fichier kernel avec un nom

  ....
   protected $middlewareAliases = [
        'langDetector'=> \App\Http\Middleware\LangueDetector::class,
  ...

Web.php

  <?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\TestController;
Route::get("/testlang",[TestController::class,"showLang"])->middleware("langDetector");

TestController.php

  <?php
namespace App\Http\Controllers;

use Illuminate\Http\Request;

class TestController extends Controller
{
public function showLang()
{
    return view("langView");

}
}

langView.blade.php.php

<div>
    Hello your language is  {{ app()->getLocale() }}
    <br/>
    Avec session : your language is : {{session('langueDetected')}}
</div>
@if(session('langueDetected')=='fr')
<nav>
    <a href="">Bonjour :</a>
    <a href=""> {{session('langueDetected')=='fr'? "Ajouter":"Add"}}</a>
    <a href="">Afficher</a>
</nav>
@endif

@if(session('langueDetected')=='en')
<nav>
    <a href="">Hello :</a>
    <a href="">ADD</a>
    <a href="">Show</a>
</nav>
@endif

Tester le middleware

Résultat :selon la langue du visiteur

  Hello your language is en
Avec session : your language is : en
Hello : ADD Show

passer de paramètre à un middleware

//...
Route::get("/testPermission",[TestController::class,"showTraiement"])->middleware("permission:ajouter,afficher,supprimer");
   

 public function handle(Request $request, Closure $next,$permission1,$permission2,$permission3,...): Response
//....

Exemple

php artisan make:middleware PermissionTest

PermissionTest

<?php
namespace App\Http\Middleware;

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

class PermissionTest
{
 
    public function handle(Request $request, Closure $next,$permission1,$permission2): Response
    {
        if($permission1=="ajouter" and $permission2=="afficher")
        {
        return $next($request);
        }
      
     return Response("Vous n'avez pas le droit d'ajouter et  afficher");
        
    }
}

Web.php

  ...
  Route::get("/testPermissionA",function (){return "Ajouter et afficher";})->middleware("permission:ajouter,afficher");
Route::get("/testPermissionB",function (){return "Ajouter ";})->middleware("permission:ajouter,,");
....

Exécution

Résultat

Vous n'avez pas le droit d'ajouter et afficher

Résultat

  Ajouter et afficher

1. Introduction aux Middleware

Les middleware dans Laravel agissent comme des filtres ou des couches intermédiaires entre une requête HTTP entrante et la réponse générée par l'application. Ils permettent de :

• Vérifier des conditions avant d'exécuter une action (authentification, autorisation, etc.).
• Modifier la requête ou la réponse.
• Restreindre l'accès à certaines routes ou fonctionnalités.

Laravel fournit des middleware par défaut (comme auth, guest, throttle), mais vous pouvez aussi créer des middleware personnalisés pour répondre à des besoins spécifiques.

2. Fonctionnement des Middleware

Un middleware est une classe PHP qui implémente une logique dans sa méthode handle. Cette méthode reçoit :

• La requête HTTP ($request).
• Une closure ($next) qui passe la requête à la prochaine étape (contrôleur ou middleware suivant).

public function handle($request, Closure $next)
{
    // Logique avant le traitement
    return $next($request); // Passe au suivant
    // Logique après le traitement (optionnel)
}

3. Création d’un Middleware

Pour créer un middleware personnalisé, utilisez la commande Artisan :

php artisan make:middleware NomDuMiddleware

Cela génère une classe dans le dossier app/Http/Middleware.

4. Enregistrement des Middleware

Après création, vous devez enregistrer le middleware dans app/Http/Kernel.php :

• Middleware global : Ajoutez-le au tableau $middleware (appliqué à toutes les requêtes).
• Middleware de groupe : Ajoutez-le à $middlewareGroups (ex. web ou api).
• Middleware spécifique : Ajoutez-le à $routeMiddleware avec une clé (ex. 'nom' => NomDuMiddleware::class).

protected $routeMiddleware = [
    'check.ip' => \App\Http\Middleware\CheckUserIp::class,
];

5. Exemples de Middleware Personnalisés

5.1 Middleware pour vérifier l’IP de l’utilisateur

Ce middleware bloque l’accès si l’IP de l’utilisateur n’est pas dans une liste autorisée.

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class CheckUserIp
{
    public function handle(Request $request, Closure $next)
    {
        $allowedIps = ['127.0.0.1', '192.168.1.1']; // IPs autorisées
        $userIp = $request->ip();

        if (!in_array($userIp, $allowedIps)) {
            return response()->json(['message' => 'Accès refusé : IP non autorisée'], 403);
        }

        return $next($request);
    }
}

Enregistrement dans Kernel.php :

'check.ip' => \App\Http\Middleware\CheckUserIp::class,

Utilisation dans une route :

Route::get('/admin', function () {
    return 'Bienvenue Admin';
})->middleware('check.ip');

5.2 Middleware pour vérifier l’User Agent

Ce middleware bloque l’accès si l’agent utilisateur (navigateur) ne correspond pas à une liste autorisée.

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class CheckUserAgent
{
    public function handle(Request $request, Closure $next)
    {
        $allowedAgents = ['Mozilla', 'Chrome']; // Agents autorisés
        $userAgent = $request->header('User-Agent');

        foreach ($allowedAgents as $agent) {
            if (stripos($userAgent, $agent) !== false) {
                return $next($request);
            }
        }

        return response()->json(['message' => 'Accès refusé : Navigateur non autorisé'], 403);
    }
}

Enregistrement :

'check.agent' => \App\Http\Middleware\CheckUserAgent::class,

Utilisation :

Route::get('/secure', function () {
    return 'Page sécurisée';
})->middleware('check.agent');

5.3 Middleware pour bloquer l’accès le week-end

Ce middleware interdit l’accès à certaines routes le samedi et dimanche.

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Carbon\Carbon;

class WeekendOff
{
    public function handle(Request $request, Closure $next)
    {
        $dayOfWeek = Carbon::now()->dayOfWeek; // 0 = Dimanche, 6 = Samedi

        if ($dayOfWeek == 0 || $dayOfWeek == 6) {
            return response()->json(['message' => 'Accès interdit le week-end'], 403);
        }

        return $next($request);
    }
}

Enregistrement :

'weekend.off' => \App\Http\Middleware\WeekendOff::class,

Utilisation :

Route::get('/work', function () {
    return 'Page de travail';
})->middleware('weekend.off');

5.4 Middleware pour les opérations CRUD

Ce middleware vérifie si l’utilisateur a le droit d’effectuer une opération CRUD (par exemple, seul un admin peut créer ou supprimer).

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class CheckCrudPermission
{
    public function handle(Request $request, Closure $next)
    {
        if (!Auth::check() || Auth::user()->role !== 'admin') {
            return response()->json(['message' => 'Accès refusé : Réservé aux admins'], 403);
        }

        return $next($request);
    }
}

Enregistrement :

'crud.permission' => \App\Http\Middleware\CheckCrudPermission::class,

Utilisation avec un groupe de routes :

Route::middleware('crud.permission')->group(function () {
    Route::post('/create', [ItemController::class, 'store']);
    Route::put('/update/{id}', [ItemController::class, 'update']);
    Route::delete('/delete/{id}', [ItemController::class, 'destroy']);
});

5.5 Middleware pour vérifier la date d’une requête

Ce middleware bloque une requête si la date actuelle est en dehors d’une plage autorisée.

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Carbon\Carbon;

class CheckDate
{
    public function handle(Request $request, Closure $next)
    {
        $startDate = Carbon::create(2025, 1, 1);
        $endDate = Carbon::create(2025, 12, 31);
        $currentDate = Carbon::now();

        if ($currentDate->lt($startDate) || $currentDate->gt($endDate)) {
            return response()->json(['message' => 'Accès refusé : Hors période autorisée'], 403);
        }

        return $next($request);
    }
}

Enregistrement :

'check.date' => \App\Http\Middleware\CheckDate::class,

Utilisation :

Route::post('/event', function () {
    return 'Événement actif';
})->middleware('check.date');

6. Middleware avec Paramètres

Vous pouvez passer des paramètres à un middleware pour le rendre plus flexible. Par exemple, un middleware qui vérifie un rôle spécifique :

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class CheckRole
{
    public function handle(Request $request, Closure $next, $role)
    {
        if (!Auth::check() || Auth::user()->role !== $role) {
            return response()->json(['message' => "Accès refusé : Rôle $role requis"], 403);
        }

        return $next($request);
    }
}

Enregistrement :

'check.role' => \App\Http\Middleware\CheckRole::class,

Utilisation :

Route::get('/admin', function () {
    return 'Page Admin';
})->middleware('check.role:admin');

Route::get('/editor', function () {
    return 'Page Éditeur';
})->middleware('check.role:editor');

7. Middleware Avant et Après

Les middleware peuvent exécuter du code avant ou après le traitement de la requête :

public function handle(Request $request, Closure $next)
{
    // Avant
    \Log::info('Requête reçue de : ' . $request->ip());

    $response = $next($request); // Traitement

    // Après
    \Log::info('Requête traitée');
    return $response;
}

8. Bonnes Pratiques

• Modularité : Créez des middleware spécifiques pour chaque tâche.
• Réutilisabilité : Utilisez des paramètres pour éviter de dupliquer le code.
• Performance : Évitez les traitements lourds dans les middleware globaux.
• Tests : Testez vos middleware avec des cas limites (ex. IP invalide, week-end, etc.).

si vous n'avez pas kernel

use App\Http\Middleware\CheckUserIp;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        // Ajouter un middleware global
        $middleware->append(CheckUserIp::class);
    })
    ->withExceptions(function (Exceptions $exceptions) {
        //
    })->create();
	

9. Conclusion

Les middleware dans Laravel sont des outils puissants pour gérer la logique de pré-traitement des requêtes. Avec les exemples ci-dessus, vous pouvez sécuriser vos applications, contrôler les accès, et personnaliser les comportements selon vos besoins (CRUD, IP, User Agent, week-end, etc.). N’hésitez pas à expérimenter et à adapter ces exemples à vos projets !

Si vous avez des questions ou souhaitez des exemples supplémentaires, faites-le-moi savoir !