Une manière très fine de diviser les fichiers de routage Laravel (traduction)

Je suppose que nous avons tous été dans une situation où nous avons un très gros fichier rempli d'itinéraires. Je ne vais pas mentir, cela m'a rendu presque fou pendant longtemps et j'ai dû trouver un moyen de résoudre ce problème. C’est ainsi que j’ai fini par construire le fichier de routage.

Tutoriel recommandé : "tutoriel Laravel"

Au départ, j'ai pensé à utiliser la méthode du groupe de routage pour recevoir des fichiers. C'est ainsi que Laravel divise l'itinéraire chez RouteServiceProvider.

<?php
namespace App\Providers;
use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Route;
class RouteServiceProvider extends ServiceProvider
{
    /**
     * This namespace is applied to your controller routes.
     *
     * In addition, it is set as the URL generator&#39;s root namespace.
     *
     * @var string
     */
    protected $namespace = &#39;App\Http\Controllers&#39;;
    /**
     * Define your route model bindings, pattern filters, etc.
     *
     * @return void
     */
    public function boot()
    {
        //
        parent::boot();
    }
    /**
     * Define the routes for the application.
     *
     * @return void
     */
    public function map()
    {
        $this->mapApiRoutes();
        $this->mapWebRoutes();
        //
    }
    /**
     * Define the "web" routes for the application.
     *
     * These routes all receive session state, CSRF protection, etc.
     *
     * @return void
     */
    protected function mapWebRoutes()
    {
        Route::middleware(&#39;web&#39;)
             ->namespace($this->namespace)
             ->group(base_path(&#39;routes/web.php&#39;));
    }
    /**
     * Define the "api" routes for the application.
     *
     * These routes are typically stateless.
     *
     * @return void
     */
    protected function mapApiRoutes()
    {
        Route::prefix(&#39;api&#39;)
             ->middleware(&#39;api&#39;)
             ->namespace($this->namespace)
             ->group(base_path(&#39;routes/api.php&#39;));
    }
}

J'ai résumé les itinéraires liés à l'utilisateur dans un fichier appelé users.php et j'ai copié mapApiRoutes en tant que mapUsersRoutes et je l'ai pointé vers mon fichier users.php.

 /**
     * Define the routes for the application.
     *
     * @return void
     */
    public function map()
    {
        $this->mapApiRoutes();
        $this->mapWebRoutes();
        $this->mapUsersRoutes();
        //
    }
/**
     * Define the "api" routes for the application.
     *
     * These routes are typically stateless.
     *
     * @return void
     */
    protected function mapUsersRoutes()
    {
        Route::prefix('api')
             ->middleware('api')
             ->namespace($this->namespace)
             ->group(base_path('routes/users.php'));
    }

Je sais ce que vous pensez, ce n'est évidemment pas la meilleure solution car à chaque fois que nous devons créer un nouveau fichier, nous devons l'enregistrer comme avant. Il m’a donc fallu affiner cette idée initiale.

J'ai eu l'idée de diviser les parties publiques de l'application en fichiers de routes séparés, et j'ai eu l'idée qu'aucune de nos routes ne pouvait aller au-delà des routes authentifiées, invitées et publiques.

J'ai optimisé la structure du dossier de routage pour ressembler à ceci :

├── routes   
│   ├── api    
│   │   ├── public
│   |   │   ├── users.php 
│   │   ├── auth
│   |   │   ├── users.php 
│   │   ├── guest
│   |   │   ├── users.php

À première vue, on pourrait penser « bon, ça ne change pas grand chose, il faut quand même mapper ces fichiers ". Cependant, nous pouvons effectivement exploiter une fonction appelée glob fournie nativement par php, qui est une solution prête à l'emploi puisque nous ne sommes pas couplés à la solution de laravel.

glob accepte une regex et peut trouver des noms de fichiers sous des chemins qui correspondent à notre regex. Nos itinéraires sont donc organisés sous des dossiers spécifiques et nous pouvons désormais retrouver tous les fichiers sous ces dossiers et les enregistrer dans leur middleware.

<?php
namespace App\Providers;
use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Route;
class RouteServiceProvider extends ServiceProvider
{
    /**
     * This namespace is applied to your controller routes.
     *
     * In addition, it is set as the URL generator&#39;s root namespace.
     *
     * @var string
     */
    protected $namespace = &#39;App\Http\Controllers&#39;;
    /**
     * Define the routes for the application.
     *
     * @return void
     */
    public function map()
    {
        $this->mapAuthRoutes();
        $this->mapGuestRoutes();
        $this->mapPublicRoutes();
//        $this->mapWebRoutes();
        //
    }
    /**
     * Define the "web" routes for the application.
     *
     * These routes all receive session state, CSRF protection, etc.
     *
     * @return void
     */
    protected function mapWebRoutes()
    {
        Route::middleware(&#39;web&#39;)
            ->namespace($this->namespace)
            ->group(base_path(&#39;routes/web.php&#39;));
    }
    /**
     * Define the "api" routes for the application.
     *
     * These routes are typically stateless.
     *
     * @return void
     */
    protected function mapAuthRoutes()
    {
        foreach (glob(base_path(&#39;routes/api/auth/*.php&#39;)) as $file) {
            Route::prefix(&#39;api&#39;)
                ->middleware([&#39;api&#39;, &#39;auth:api&#39;])
                ->group($file);
        }
    }
    protected function mapGuestRoutes()
    {
        foreach (glob(base_path(&#39;routes/api/guest/*.php&#39;)) as $file) {
            Route::prefix(&#39;api&#39;)
                ->middleware([&#39;api&#39;, &#39;guest:api&#39;])
                ->group($file);
        }
    }
    protected function mapPublicRoutes()
    {
        foreach (glob(base_path(&#39;routes/api/public/*.php&#39;)) as $file) {
            Route::prefix(&#39;api&#39;)
                ->middleware(&#39;api&#39;)
                ->group($file);
        }
    }
}

Maintenant, chaque fois que nous créons un nouveau fichier, foreach le trouvera car il utilise la correspondance regex (le fichier se trouve sous le chemin correspondant et a une extension PHP, il correspond donc à notre correspondance habituelle). C'est tellement sexy ! Mais s'il vous plaît, attendez un moment.

Comment ces documents seront-ils enregistrés ?

Si vous avez étudié le cycle de vie de Laravel, vous savez que les fournisseurs de services font partie du cycle de vie des requêtes Laravel et nous pouvons utiliser cette fonctionnalité pour enregistrer dynamiquement nos itinéraires.

Ça y est ! J'espère que vous l'aimerez.

Adresse originale : https://dev.to/secmohammed/how-to-separa...

Adresse de traduction : https://learnku.com/laravel/t /42989

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!