Mastering PHP Design Patterns: From Basics to Practical Expertise

Introduction to PHP Design Patterns

Design patterns are proven solutions for recurring software development challenges. In PHP, applying design patterns helps developers create code that is more maintainable, scalable, and reusable. They serve as best practices for writing robust and elegant systems.

The Three Categories of PHP Design Patterns

Design patterns are typically divided into three categories: creational, structural, and behavioral. Each focuses on solving specific types of design problems.

Creational Patterns

Creational patterns deal with object creation mechanisms, aiming to make systems independent of how their objects are created or composed. Common examples include:

• Factory Pattern: Creates objects without specifying their exact classes.
• Singleton Pattern: Ensures that a class has only one instance throughout the application.

Structural Patterns

Structural patterns focus on how classes and objects are composed to form larger structures while keeping flexibility and efficiency. Common examples include:

• Adapter Pattern: Enables incompatible interfaces to work together.
• Proxy Pattern: Provides controlled access to an object by acting as an intermediary.
• Decorator Pattern: Dynamically adds new functionality to existing objects without altering their structure.

Behavioral Patterns

Behavioral patterns define how objects interact and distribute responsibilities among them. Common examples include:

• Observer Pattern: Implements a publish/subscribe mechanism for notifications.
• Strategy Pattern: Allows selecting an algorithm or behavior at runtime.
• Template Method Pattern: Defines the skeleton of an algorithm, allowing subclasses to customize specific steps.

Practical Example: Applying Design Patterns in a Shopping Cart System

The following example demonstrates the use of factory, proxy, and strategy patterns in a PHP shopping cart system.

Using the Factory Pattern to Create Discount Service Objects

interface DiscountServiceFactory {
  public static function create(): DiscountService;
}

class NormalDiscountService implements DiscountService {
  // ...
}

class PremiumDiscountService implements DiscountService {
  // ...
}

class DiscountServiceFactoryImpl implements DiscountServiceFactory {
  public static function create(): DiscountService {
    if (isPremiumCustomer()) {
      return new PremiumDiscountService();
    }
    return new NormalDiscountService();
  }
}

The factory pattern encapsulates the creation logic, allowing you to generate different discount service instances based on customer type without modifying client code.

Using the Proxy Pattern to Add Logging to the Cart

class CartLoggerProxy extends Cart {
  private $logger;

  public function __construct(Cart $cart, Logger $logger) {
    parent::__construct();
    $this->cart = $cart;
    $this->logger = $logger;
  }

  public function addItem(Item $item): void {
    parent::addItem($item);
    $this->logger->log("Added item to cart");
  }

  // Additional methods can be handled similarly
}

The proxy pattern enhances an existing class by adding extra functionality, such as logging or access control, without changing the original implementation.

Using the Strategy Pattern for Different Discount Calculations

interface DiscountStrategy {
  public function calculateDiscount(Cart $cart): float;
}

class NoDiscountStrategy implements DiscountStrategy {
  public function calculateDiscount(Cart $cart): float {
    return 0;
  }
}

class FlatDiscountStrategy implements DiscountStrategy {
  private $discount;

  public function __construct(float $discount) {
    $this->discount = $discount;
  }

  public function calculateDiscount(Cart $cart): float {
    return $cart->getTotal() * $this->discount;
  }
}

// Applying strategies
$context = new DiscountContext();

if (isPremiumCustomer()) {
  $context->setStrategy(new PremiumDiscountStrategy());
} else {
  $context->setStrategy(new NoDiscountStrategy());
}

$discount = $context->calculateDiscount();

The strategy pattern allows dynamic selection of discount algorithms, making the system more flexible and easier to extend as new business rules emerge.

Conclusion

Design patterns are more than coding techniques—they represent structured approaches to problem-solving. By applying patterns such as factory, proxy, and strategy, PHP developers can build systems that are clean, adaptable, and easy to maintain. Mastering these patterns is a crucial step toward becoming a proficient PHP engineer.