How to Create Multi Route Files in Laravel

Creating multiple route files in Laravel is an effective strategy for organizing and managing your application’s routes, especially as your project expands. As applications grow in complexity and size, maintaining a clean and modular structure becomes essential. By separating routes into different files, you can enhance the clarity of your code, making it significantly easier to manage and scale your application efficiently. In this guide, we will walk you through the process of setting up multi-routing in Laravel, which includes creating route files for different sections of your application, modifying the RouteServiceProvider, and ensuring that everything functions seamlessly.

Step-By-Step Guide

This section provides a detailed overview of the steps required to implement multi route files in your Laravel application. Each step is broken down into sub-steps to ensure clear understanding and easy implementation.

Step 1: Create Custom Route Files

The initial step in implementing multi-routing is to create new route files that will cater to different sections of your application. For instance, we will create separate route files specifically for admin and user routes. This separation allows you to group related routes together, making them easier to manage.

Create New Route Files

To begin, you can create new route files for the different sections of your application:

touch routes/admin.php

touch routes/user.php

Define Routes in New Files

In these newly created files, you can define routes that are specific to each section. This method of organization is particularly beneficial for larger applications.

routes/admin.php

This file will hold routes related to the admin section. You can define a route for accessing the admin dashboard:

<?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\Admin\AdminController;

Route::middleware('auth')->group(function () {
    Route::get('/dashboard', [AdminController::class, 'dashboard'])->name('admin.dashboard');
}

routes/user.php

This file will include routes pertinent to the user section:

<?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\User\UserController;

Route::middleware('auth')->group(function () {
    Route::get('/dashboard', [UserController::class, 'dashboard'])->name('user.dashboard');
}

Step 2: Modify RouteServiceProvider

Next, you need to modify the RouteServiceProvider to load these custom route files. The RouteServiceProvider is responsible for loading your route definitions and ensuring that they are correctly applied in your application.

Open RouteServiceProvider

Open the file located at app/Providers/RouteServiceProvider.php to make the necessary modifications.

Load the Custom Route Files in the Boot Method

Within the boot method, specify the paths to the new route files while applying the necessary middleware:

<?php
namespace App\Providers;

use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Route;

class RouteServiceProvider extends ServiceProvider
{
    public function boot()
    {
        $this->routes(function () {
            Route::prefix('admin')->middleware('web')->group(base_path('routes/admin.php'));
            Route::prefix('user')->middleware('web')->group(base_path('routes/user.php'));
        });
    }
}

In this code snippet:

• Route::prefix(‘admin’) specifies that routes defined in routes/admin.php should have the prefix /admin.
• Route::prefix(‘user’) specifies that routes defined in routes/user.php should have the prefix /user.

Step 3: Organize Controllers

Ensure that your controllers are placed within the appropriate namespaces corresponding to the route files. This organization will help maintain clarity and avoid confusion.

Create and Place Controllers

Admin-related controllers should be in app/Http/Controllers/Admin, while user-related controllers should reside in app/Http/Controllers/User.

Admin Controller Example

Create the controller for handling admin-related logic – app/Http/Controllers/Admin/AdminController.php:

<?php
namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;

class AdminController extends Controller
{
    public function dashboard()
    {
        return view('admin.dashboard');
    }
}

User Controller Example

Create the controller for user-related logic – app/Http/Controllers/User/UserController.php:

<?php
namespace App\Http\Controllers\User;

use App\Http\Controllers\Controller;

class UserController extends Controller
{
    public function dashboard()
    {
        return view('user.dashboard');
    }
}

Step 4: Create Views for Dashboards

After setting up your controllers, create view files that will render the content for each section’s dashboard.

Admin Dashboard View

Now create the view file for the user dashboard at resources/views/admin/dashboard.blade.php:

<!DOCTYPE html>
<html>
    <head>
        <title>Admin Dashboard</title>
    </head>
    <body>
        <h1>Welcome to the Admin Dashboard</h1>
    </body>
</html>

User Dashboard View

Create the view file for the user dashboard at resources/views/user/dashboard.blade.php:

<!DOCTYPE html>
<html>
    <head>
        <title>User Dashboard</title>
    </head>
    <body>
        <h1>Welcome to the User Dashboard</h1>
    </body>
</html>

Step 5: Test Your Routes

With everything set up, verify that your routing works as intended. Start your application using Laravel’s built-in Artisan command:

php artisan serve

Access Your Routes

Visit the defined routes in your web browser to ensure they are functioning correctly:

• Admin Dashboard: http://localhost:8000/admin/dashboard
• User Dashboard: http://localhost:8000/user/dashboard

Benefits

Utilizing multiple route files in Laravel brings several advantages:

• Improved Organization: Separating routes into different files enhances the organization of your route definitions, making them easier to manage and comprehend.
• Scalability: As your application grows, managing all routes in a single file can become overwhelming. Employing multiple route files allows for a more scalable approach to routing.
• Modularity: By assigning prefixes and grouping routes by functionality (such as admin and user routes), you enhance modularity and keep related routes together.
• Ease of Maintenance: A clean and organized routing structure simplifies the maintenance and updating of routes.

Implementing a multi-routing setup in Laravel keeps your codebase clean and significantly enhances your application’s overall maintainability and scalability.

Conclusion

Creating multiple route files in Laravel, combined with an effective organization strategy using prefixes, allows you to maintain a clean and modular codebase. This method provides immense benefits, particularly for larger applications, as it ensures a well-structured and manageable routing system. By following the steps outlined in this guide, you can effectively set up and manage multiple route files, leading to improved organization and scalability in your Laravel application.