PHP Course: Design Patterns in Practice

Introduction to Design Patterns in PHP

Design patterns in PHP are templates that help in creating applications compliant with best practices. They allow for the creation of scalable and easy-to-maintain information systems. Design patterns are particularly useful in object-oriented programming because they enable the use of experience and knowledge from other programmers. Thanks to design patterns, PHP programmers can avoid common errors, accelerate the application creation process, and ensure that code will be more readable and understandable for other team members.

Design patterns such as Singleton, Abstract Factory, or Decorator are the foundation for creating solid and flexible applications. Each of these patterns solves specific design problems, allowing for more effective code management and its future expansion. Introduction to design patterns is the first step towards writing professional code in PHP. All examples presented below are compliant with the latest PHP versions and come from the practical PHP 8.4 course in ebook form.

What are Design Patterns?

Design patterns are proven solutions to common programming problems that allow for faster, more efficient, and more readable application development. They are like signposts that help programmers write code that is not only functional but primarily readable, easy to maintain and expand. Knowledge of design patterns is a key competency required by today"s job market from every PHP programmer.

In the era of dynamic PHP development – especially in the face of the latest PHP 8.4 version – the ability to effectively use design patterns is more valuable than ever before. Using these patterns allows for shorter code writing time, avoiding common errors, and creating applications compliant with industry best practices. If you dream of writing professional, well-organized, and future-proof PHP code, design patterns should be on your priority list.

Facade
Factory
Singleton
Decorator
Builder

Facade Design Pattern in PHP 8.4

The Facade design pattern enables simplifying the interface of a complex system, providing one cohesive class for performing various operations. The QueryBuilder class from chapter 8 of the ebook "DBAL - query builder" perfectly illustrates this pattern. Thanks to using facade, programmers can easily generate different types of database queries – without the need to delve into implementation details of individual classes responsible for building specific queries.

<?php

declare(strict_types=1);

namespace DJWeb\Framework\DBAL\Query\Builders;

use DJWeb\Framework\Base\Application;

class QueryBuilder implements QueryBuilderFacadeContract
{
    public function insert(string $table): InsertQueryBuilderContract
    {
        /** @var InsertQueryBuilderContract $item */
        $item = Application::getInstance()->get(InsertQueryBuilderContract::class);
        $item->clean();
        return $item->table($table);
    }

    public function update(string $table): UpdateQueryBuilderContract
    {
        /** @var UpdateQueryBuilderContract $item */
        $item = Application::getInstance()->get(UpdateQueryBuilderContract::class);
        $item->clean();
        return $item->table($table);
    }

    public function delete(string $table): DeleteQueryBuilderContract
    {
        /** @var DeleteQueryBuilderContract $item */
        $item = Application::getInstance()->get(DeleteQueryBuilderContract::class);
        $item->clean();
        return $item->table($table);
    }

    public function select(string $table): SelectQueryBuilderContract
    {
        /** @var SelectQueryBuilderContract $item */
        $item = Application::getInstance()->get(SelectQueryBuilderContract::class);
        $item->clean();
        return $item->table($table);
    }
}

Factory Design Pattern in PHP 8.4

The Factory design pattern is used to create objects whose initialization can be complex or dependent on many configuration parameters. A great example of using this pattern is the MailerFactory class from chapter 20 of the ebook "Email sending", which provides static methods such as createSmtpMailer() or createMailHogMailer(). Thanks to this, the programmer doesn"t have to manually build the Mailer object along with the appropriate DSN string, but uses ready, clearly named factory methods.

<?php

declare(strict_types=1);

namespace DJWeb\Framework\Mail;

final class MailerFactory
{
    public static function createSmtpMailer(
        string $host,
        int $port,
        string $username,
        string $password
    ): MailerContract {
        $dsn = sprintf(
            "smtp://%s:%s@%s:%d",
            $username,
            $password,
            $host,
            $port
        );
        return new Mailer($dsn);
    }

    public static function createMailHogMailer(
        string $host = "localhost",
        int $port = 1025
    ): MailerContract {
        $dsn = sprintf("smtp://%s:%d", $host, $port);
        return new Mailer($dsn);
    }
}

Singleton Design Pattern in PHP 8.4

The Singleton pattern is a design approach that ensures the existence of only one class instance throughout the entire application lifecycle, while providing a global access point to that instance. The Application class from chapter 3 of the ebook, which implements a dependency container (Dependency Injection), is an excellent example of using this pattern. The static getInstance() method provides access to a single application instance, ensuring that each component uses the same configuration and resources.

Want to see more practical examples? Download free ebook sample 📥 or Buy PHP course 🎓

Design Patterns in PHP - Practical Application