Introduction

When building a web application, one of the most important concepts to understand is how the application responds to different URLs. In Laravel, this process is handled by a powerful feature called routing.

Routing is responsible for directing incoming HTTP requests to the appropriate part of your application. When a user visits a specific URL in their browser, Laravel uses its routing system to determine what code should run and what response should be returned.

Without routing, a web application would not know how to handle different pages, actions, or API requests. Routing acts as the bridge between the user’s request and the logic that processes that request.

Laravel provides a clean and expressive routing system that allows developers to define routes in a simple and readable way. Instead of writing complicated configuration files, developers can define routes using straightforward syntax.

In this guide, we will explore how Laravel routing works, how to define routes, and how routes connect with controllers and middleware in modern Laravel applications.

What is Routing in Laravel?

Routing in Laravel refers to the process of mapping a URL request to a specific function, controller method, or action within the application.

When a user types a URL into their browser, the request is sent to the Laravel application. Laravel then checks the list of defined routes to determine how the request should be handled.

For example, if a user visits a URL such as /about, Laravel can return an "About Us" page. If the user visits /products, Laravel may retrieve products from a database and display them.

Routes define how different URLs behave in your application.

Laravel organizes route definitions in a dedicated folder called routes. The most commonly used route file for web applications is web.php.

CODE EXAMPLE 1 (Basic Route)

Route::get('/welcome', function () {
    return 'Welcome to Laravel!';
});

This route tells Laravel that when a user visits /welcome, the application should return a simple text response.

Understanding HTTP Methods

When defining routes in Laravel, developers must specify the HTTP method used for the request.

HTTP methods represent the type of action being performed. Some of the most common HTTP methods include:

• GET – Retrieve data from the server

• POST – Send data to the server

• PUT – Update existing data

• DELETE – Remove data

Laravel allows developers to define routes for each of these HTTP methods.

CODE EXAMPLE 2 (HTTP Methods)

Route::get('/posts', function () {
    return 'Display all posts';
});

Route::post('/posts', function () {
    return 'Create a new post';
});

Using different HTTP methods helps structure web applications according to RESTful design principles.

Routing to Controllers

While simple routes can use closures, larger applications typically use controllers to organize logic.

A controller is a class that contains methods responsible for handling requests. Instead of placing logic directly in the route file, developers can delegate the work to controller methods.

This approach keeps routes clean and improves code organization.

CODE EXAMPLE 3 (Route to Controller)

use App\Http\Controllers\PostController;

Route::get('/posts', [PostController::class, 'index']);

In this example, Laravel calls the index method inside the PostController when the /posts route is accessed.

Route Parameters

Often, routes need to accept dynamic values from the URL. For example, a blog might display different articles based on an ID or slug.

Laravel supports route parameters, allowing developers to capture parts of the URL and pass them into the application.

Route parameters are defined using curly braces.

CODE EXAMPLE 4 (Route Parameter)

Route::get('/posts/{id}', function ($id) {
    return "Post ID: " . $id;
});

If a user visits /posts/5, the value 5 will be captured as the $id parameter.

Optional Route Parameters

Laravel also supports optional parameters. This allows a route to work even if the parameter is not provided.

Optional parameters are defined by adding a question mark after the parameter name.

CODE EXAMPLE 5 (Optional Parameter)

Route::get('/user/{name?}', function ($name = "Guest") {
    return "Hello " . $name;
});

If no name is provided in the URL, the default value "Guest" will be used.

Named Routes

Named routes allow developers to assign a name to a route. This makes it easier to generate URLs or redirects within the application.

Instead of referencing routes by their full URL, developers can reference them by name.

Named routes improve maintainability, especially in large applications.

CODE EXAMPLE 6 (Named Route)

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

Later in the application, this route can be referenced using its name.

CODE EXAMPLE 7 (Using Named Route)

route('dashboard');

This will generate the URL associated with the dashboard route.

Route Groups

Laravel allows developers to group related routes together. Route groups help organize routes that share common properties such as middleware, prefixes, or namespaces.

For example, all admin routes can be grouped under a common URL prefix.

CODE EXAMPLE 8 (Route Group)

Route::prefix('admin')->group(function () {
    Route::get('/dashboard', function () {
        return "Admin Dashboard";
    });

    Route::get('/users', function () {
        return "Manage Users";
    });
});

Route::get('/profile', function () {
    return "User Profile";
})->middleware('auth');