Laravel Design Patterns: A Beginner's Guide

Laravel is a powerful PHP framework that makes web development easier and more enjoyable. One of the reasons for its popularity is its use of design patterns, which are like recipes or blueprints for solving common problems in software development. These patterns provide tried-and-tested solutions that you can adapt to your projects, making your code more organized, maintainable, and scalable.

In this blog, we’ll explore some of the key design patterns used in Laravel, explain them in simple terms, and provide code examples to help beginners understand how they work. We’ll cover the MVC Pattern, Dependency Injection, Facade Pattern, and briefly touch on the Repository Pattern. Let’s dive in!

What Are Design Patterns?

Imagine you’re cooking a meal. A recipe tells you the steps to follow to make a delicious dish. Similarly, a design pattern is a reusable solution to a common problem in software design. It’s not a piece of code you copy-paste but a template you can customize for your needs.

Laravel uses several design patterns to streamline development. In this guide, we’ll focus on the ones you’ll encounter most often as a beginner.

1. MVC Pattern in Laravel

The Model-View-Controller (MVC) pattern is the foundation of Laravel’s structure. It splits your application into three main parts:

• Model: Handles the data and business logic (e.g., interacting with the database).
• View: Manages the presentation layer (e.g., what the user sees on the screen).
• Controller: Acts as a middleman, processing user input, updating the Model, and passing data to the View.

How It Works in Laravel: Models in Laravel are typically Eloquent ORM classes representing database tables. Views are Blade templates that generate HTML, and controllers handle HTTP requests by coordinating between models and views.

Code Example: Displaying a List of Users

Step 1: The Model

<?php
// app/Models/User.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model {
    // This Eloquent model interacts with the 'users' table
    protected $fillable = ['name', 'email'];
}

Step 2: The Controller

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

use App\Models\User;

class UserController extends Controller {
    public function index() {
        // Fetch all users from the database
        $users = User::all();
        // Pass the users to the view
        return view('users.index', compact('users'));
    }
}

Step 3: The View

<!-- resources/views/users/index.blade.php -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Users List</title>
</head>
<body>
    <h1>Users List</h1>
    <ul>
        @foreach ($users as $user)
            <li>{{ $user->name }} ({{ $user->email }})</li>
        @endforeach
    </ul>
</body>
</html>

Step 4: The Route

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

Route::get('/users', [UserController::class, 'index']);

When you visit /users in your browser, the UserController fetches all users from the User model and passes them to the Blade template to display them as a list.

2. Dependency Injection in Laravel

Dependency Injection (DI) is a way to supply a class with its required dependencies from the outside rather than creating them within the class. This makes your code more flexible, testable, and easier to maintain.

In Laravel, the service container handles DI automatically. You can inject services or classes into controllers, middleware, or even method parameters.

Code Example: Injecting a User Service

Step 1: The Service

<?php
// app/Services/UserService.php
namespace App\Services;

use App\Models\User;

class UserService {
    public function getAllUsers() {
        return User::all();
    }
}

Step 2: The Controller

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

use App\Services\UserService;

class UserController extends Controller {
    protected $userService;

    // Inject UserService via the constructor
    public function __construct(UserService $userService) {
        $this->userService = $userService;
    }

    public function index() {
        $users = $this->userService->getAllUsers();
        return view('users.index', compact('users'));
    }
}

Here, Laravel’s service container automatically injects an instance of UserService into the controller.

3. Facade Pattern in Laravel

The Facade Pattern provides a simple, static-like interface to access services in the service container. Facades make your code cleaner by hiding the complexity of dependency resolution.

Code Example: Using the Cache Facade

<?php
// In a controller or anywhere in your app
use Illuminate\Support\Facades\Cache;

class ExampleController extends Controller {
    public function testCache() {
        // Store a value in the cache for 10 minutes
        Cache::put('key', 'Hello, Laravel!', 10);
        // Retrieve the value
        $value = Cache::get('key');
        return $value; // Outputs: Hello, Laravel!
    }
}

Facades like Cache provide a clear, concise way to interact with Laravel's underlying services.

4. Repository Pattern in Laravel (Optional)

The Repository Pattern abstracts the data access layer, so your controllers don’t directly interact with the models. This makes it easier to swap out data sources (like changing the database) and improves testability.

Code Example: A User Repository

Step 1: The Repository

<?php
// app/Repositories/UserRepository.php
namespace App\Repositories;

use App\Models\User;

class UserRepository {
    public function all() {
        return User::all();
    }

    public function find($id) {
        return User::find($id);
    }
}

Step 2: The Controller

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

use App\Repositories\UserRepository;

class UserController extends Controller {
    protected $userRepository;

    public function __construct(UserRepository $userRepository) {
        $this->userRepository = $userRepository;
    }

    public function index() {
        $users = $this->userRepository->all();
        return view('users.index', compact('users'));
    }
}

Although using the Repository Pattern is optional for beginners, it becomes valuable as your application grows.

Conclusion

Design patterns are powerful tools that help you write better code in Laravel. Here’s a quick recap:

• MVC: Organizes your app into Models, Views, and Controllers for clear separation of concerns.
• Dependency Injection: Makes your code modular and testable by letting Laravel manage dependencies.
• Facades: Simplify access to services with a clean, static-like syntax.
• Repository Pattern (Optional): Abstracts data access for flexibility and maintainability.

As a beginner, start by getting comfortable with MVC, then gradually explore Dependency Injection and Facades. These patterns will give you a strong foundation for building robust Laravel applications.

Keep practicing, and soon you’ll be using these patterns naturally in your projects. Happy coding!