🚦 Routing and Controllers

What Routing Is

Routing maps an incoming URL and HTTP verb to the code that should handle it. Routes are the switchboard operators of your app: they take each request and connect it to the right controller action, closure, or view.

A useful real-world picture is a post office. Each letter (request) carries an address (URL) and an instruction (verb — deliver, return, forward). The sorting system (router) reads both and sends it to the correct destination (controller action).

Basic Routes & HTTP Verbs

Laravel gives you an expressive method per HTTP verb. The simplest route returns a value directly; most real routes point to a controller action using the [Controller::class, 'method'] array syntax.

<?php
use App\Http\Controllers\ContactController;
use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;

// A closure route that returns a string
Route::get('/hello', function () {
    return 'Hello World';
});

// A route pointing at a controller action, given a name
Route::get('/profile', [ProfileController::class, 'show'])->name('profile');

// Multiple verbs on one URL
Route::match(['get', 'post'], '/contact', [ContactController::class, 'handle']);

Each verb corresponds to an intent, and they line up neatly with CRUD operations:

Parameters, Constraints & Names

Route parameters

Wrap a URL segment in braces to capture it. Add a ? for an optional parameter (give the matching argument a default).

<?php
// Required parameter
Route::get('/users/{id}', function (string $id) {
    return "User with ID: {$id}";
});

// Optional parameter
Route::get('/users/{id?}', function (?string $id = null) {
    return $id ? "User {$id}" : 'All users';
});

Constraints

Use where() to restrict a parameter to a pattern, or the built-in helpers like whereNumber(). A non-matching URL simply won't match the route (yielding a 404).

<?php
// Only match a numeric id
Route::get('/users/{id}', [UserController::class, 'show'])
    ->whereNumber('id');

// Multiple constraints via a pattern
Route::get('/posts/{slug}/{id}', [PostController::class, 'show'])
    ->where(['slug' => '[A-Za-z0-9\-]+', 'id' => '[0-9]+']);

Named routes

Naming a route lets you refer to it by name instead of hardcoding its URL. Change the URL later and every reference keeps working.

<?php
Route::get('/user/{id}/profile', [ProfileController::class, 'show'])
    ->name('profile.show');

// Generate the URL by name (with parameters)
$url = route('profile.show', ['id' => 1]);   // "/user/1/profile"

// Redirect to a named route
return redirect()->route('profile.show', ['id' => 1]);

💡 Analogy: Named routes are contacts in your phone. You don't memorize the number (URL) — you tap the name. If the person changes numbers, your contact still reaches them.

Route Groups

Route groups share attributes — a URL prefix, middleware, or a name prefix — across many routes, so you write them once instead of repeating them on every line.

<?php
// Prefix + middleware + name prefix, all shared
Route::prefix('admin')
    ->middleware(['auth', 'can:access-admin'])
    ->name('admin.')
    ->group(function () {
        Route::get('/users', [AdminController::class, 'users'])->name('users');
        Route::get('/settings', [AdminController::class, 'settings'])->name('settings');
        // URLs: /admin/users and /admin/settings
        // Names: admin.users and admin.settings
    });

Groups can nest, which is perfect for versioned APIs:

<?php
Route::prefix('api')->group(function () {
    Route::prefix('v1')->group(function () {
        Route::get('/users', [Api\V1\UserController::class, 'index']);
    });
    Route::prefix('v2')->group(function () {
        Route::get('/users', [Api\V2\UserController::class, 'index']);
    });
});
// Produces /api/v1/users and /api/v2/users

Route Model Binding

Instead of receiving an id and looking the record up yourself, you can type-hint the model and Laravel fetches it automatically — returning a 404 if nothing matches. This is route model binding, and it eliminates a huge amount of repetitive code.

Implicit binding

<?php
// The {user} segment name matches the $user type-hint
Route::get('/users/{user}', [UserController::class, 'show']);

class UserController extends Controller
{
    public function show(User $user)
    {
        // Laravel already fetched the User by primary key (or 404'd)
        return view('users.show', ['user' => $user]);
    }
}

Binding by a different column

Want pretty URLs like /posts/my-article instead of /posts/42? Specify the column right in the route:

<?php
// Resolve the Post by its "slug" column instead of the id
Route::get('/posts/{post:slug}', [PostController::class, 'show']);

💡 Analogy: Binding is an assistant who hears a name and instantly places the right file on your desk — no rummaging through the cabinet by ID number.

Controllers

A controller groups related request-handling logic into one class. It is the conductor: it takes the request, coordinates models and services, and returns a response. Generate one with Artisan:

php artisan make:controller UserController               # empty controller
php artisan make:controller PhotoController --resource    # 7 CRUD methods
php artisan make:controller ShowDashboard --invokable     # single-action

Resource controllers

A single line registers all seven conventional CRUD routes and maps them to matching methods. This is the standard way to expose a resource.

<?php
// One line = seven routes
Route::resource('photos', PhotoController::class);

// Or a subset
Route::resource('photos', PhotoController::class)->only(['index', 'show']);

For JSON-only APIs, use apiResource(), which omits the create and edit methods (those exist only to serve HTML forms).

<?php
Route::apiResource('products', ProductController::class);

Single-action controllers

When a controller does exactly one thing, give it an __invoke method and reference the class directly.

<?php
namespace App\Http\Controllers;

class ShowDashboard extends Controller
{
    public function __invoke()
    {
        return view('dashboard');
    }
}

// Route — no method name needed
Route::get('/dashboard', ShowDashboard::class);

Validation & Responses

Validating input

Never trust incoming data. The validate() method checks the request against rules; on failure it automatically redirects back with errors (or returns a 422 JSON response for API requests). On success it returns the validated data.

<?php
public function store(Request $request)
{
    $validated = $request->validate([
        'title'        => 'required|string|max:255',
        'body'         => 'required',
        'published_at' => 'nullable|date',
    ]);

    Article::create($validated);

    return redirect()->route('articles.index')
        ->with('status', 'Article created!');
}

Validation is a quality-control checkpoint — data must pass inspection before it reaches your database.

Response types

Controllers return whatever the situation calls for:

<?php
// A rendered Blade view
return view('users.profile', ['user' => $user]);

// JSON (Content-Type set automatically), with a status code
return response()->json(['error' => 'Unauthorized'], 401);

// A file download with a custom name
return response()->download($pathToFile, 'report.pdf');

// A redirect to a named route
return redirect()->route('login');

// Redirect back to the previous page, keeping the old input
return back()->withInput();

Hands-on Exercise

<?php
// routes/web.php
use App\Http\Controllers\ProductController;

Route::resource('products', ProductController::class);

<?php
// app/Http/Controllers/ProductController.php
namespace App\Http\Controllers;

use App\Models\Product;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    public function index()
    {
        $products = Product::paginate(12);

        return view('products.index', compact('products'));
    }

    public function show(Product $product)   // route model binding
    {
        return view('products.show', compact('product'));
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'name'        => 'required|string|max:255',
            'price_cents' => 'required|integer|min:0',
        ]);

        Product::create($validated);

        return redirect()->route('products.index')
            ->with('status', 'Product added!');
    }
}

Summary & Quiz

📚 Further Reading

• Laravel Docs — Routing
• Laravel Docs — Controllers
• Laravel Docs — Route Model Binding
• Laravel Docs — Validation

🚀 What's Next?

Your controllers can now handle requests and return views — but those views are still plain HTML. Next we meet Blade, Laravel's template engine, which brings layouts, components, loops, and conditionals to your presentation layer.