Detailed explanation of PHP design patterns in practice

Design patterns provide proven solutions for software design to common programming problems. This article takes an in-depth look at common design patterns in PHP and explains them through practical cases, covering singleton pattern, factory method pattern and observer pattern.

Detailed practical explanation of PHP design patterns

Design patterns provide a set of proven solutions for software design to solve common problems Programming questions. This article will delve into the commonly used design patterns in PHP and illustrate them through practical cases.

Singleton mode

The singleton mode ensures that a class is instantiated only once. This is useful for global resources or configuration managers.

class Database {
  private static ?\PDO $instance = null;

  private function __construct() {}

  public static function getInstance(): \PDO {
    if (self::$instance === null) {
      self::$instance = new \PDO('mysql:host=localhost;dbname=my_db', 'user', 'password');
    }

    return self::$instance;
  }
}

// 使用 Singleton
$db1 = Database::getInstance();
$db2 = Database::getInstance();

// 两个变量指向同一个 PDO 对象
var_dump($db1 === $db2); // true

Factory Method Pattern

The Factory Method pattern defines an interface that creates objects, but allows subclasses to change the creation process. This provides a flexible way to separate creation logic and product classes.

interface Shape {
  public function draw(): void;
}

class Circle implements Shape {
  public function draw(): void {
    echo 'Drawing a circle.' . PHP_EOL;
  }
}

class Square implements Shape {
  public function draw(): void {
    echo 'Drawing a square.' . PHP_EOL;
  }
}

class ShapeFactory {
  public static function createShape(string $type): Shape {
    switch ($type) {
      case 'circle':
        return new Circle();
      case 'square':
        return new Square();
      default:
        throw new InvalidArgumentException('Invalid shape type.');
    }
  }
}

// 使用工厂方法
$circle = ShapeFactory::createShape('circle');
$square = ShapeFactory::createShape('square');

$circle->draw(); // Drawing a circle.
$square->draw(); // Drawing a square.

Observer Pattern

The Observer pattern defines a one-to-many dependency relationship, in which one object (subject) can notify multiple objects (observers) Status changes.

interface Subject {
  public function attach(Observer $observer): void;
  public function detach(Observer $observer): void;
  public function notify(): void;
}

class NewsPortal implements Subject {
  private array $observers = [];
  private string $latestNews;

  public function attach(Observer $observer): void {
    $this->observers[] = $observer;
  }

  public function detach(Observer $observer): void {
    unset($this->observers[array_search($observer, $this->observers)]);
  }

  public function notify(): void {
    foreach ($this->observers as $observer) {
      $observer->update($this);
    }
  }

  public function publishNews(string $news): void {
    $this->latestNews = $news;
    $this->notify();
  }
}

interface Observer {
  public function update(Subject $subject): void;
}

class NewsReader implements Observer {
  public function update(Subject $subject): void {
    $news = $subject->getLatestNews();
    echo 'Received latest news: ' . $news . PHP_EOL;
  }
}

// 使用观察者模式
$newsPortal = new NewsPortal();
$reader1 = new NewsReader();
$reader2 = new NewsReader();

$newsPortal->attach($reader1);
$newsPortal->attach($reader2);

$newsPortal->publishNews('New developments in the ongoing war.');
$newsPortal->detach($reader2);
$newsPortal->publishNews('Another major breakthrough in science.');

The above is the detailed content of Detailed explanation of PHP design patterns in practice. For more information, please follow other related articles on the PHP Chinese website!