An article exploring the differences between common PHP design patterns

With the development of technology, design patterns play an increasingly important role in software development. Design patterns are defined as a set of reusable solutions to common problems in object-oriented software development. PHP has also integrated design patterns since version 5, which brings great convenience to PHP developers. This article will introduce the differences between common PHP design patterns.

1. Singleton pattern

The singleton pattern is a common design pattern that ensures that only one instance of a class is created and provides a way to access the instance methods. The singleton pattern in PHP can be implemented by using static variables. The following is an example of using singleton mode to create a database connection:

class Database
{
   private static $instance;
   private $connection;

   private function __construct()
   {
       $this->connection = new mysqli('localhost', 'user', 'password', 'database');
   }

   public static function getInstance()
   {
       if (!isset(self::$instance)) {
           self::$instance = new Database();
       }

       return self::$instance;
   }

   public function getConnection()
   {
       return $this->connection;
   }
}

$database = Database::getInstance();
$connection = $database->getConnection();

2. Factory mode

Factory mode is a creation mode used to create for clients object. The factory pattern decouples client code from the specific object creation process by using factory methods. The factory pattern in PHP can be implemented using abstract factory, simple factory and factory method. The following is an example of using a factory method to create an object:

interface Car
{
   public function run();
}

class BMW implements Car
{
   public function run()
   {
       echo "BMW is running\n";
   }
}

class Benz implements Car
{
   public function run()
   {
       echo "Benz is running\n";
   }
}

interface CarFactory
{
   public function createCar();
}

class BMWFactory implements CarFactory
{
   public function createCar()
   {
       return new BMW();
   }
}

class BenzFactory implements CarFactory
{
   public function createCar()
   {
       return new Benz();
   }
}

$bmwFactory = new BMWFactory();
$bmw = $bmwFactory->createCar();
$bmw->run();

$benzFactory = new BenzFactory();
$benz = $benzFactory->createCar();
$benz->run();

3. Observer pattern

The observer pattern is a behavioral pattern used between objects Establish a one-to-many dependency relationship so that when the state of an object changes, all objects that depend on it can be automatically notified and updated. The observer pattern in PHP can be implemented using the spl_subject class and spl_observer interface. The following is an example of using the observer pattern to implement email subscription:

class NewsPublisher implements SplSubject
{
   private $observers = [];
   private $news;

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

   public function detach(SplObserver $observer)
   {
       $key = array_search($observer, $this->observers, true);
       if ($key !== false) {
           unset($this->observers[$key]);
       }
   }

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

   public function publish($news)
   {
       $this->news = $news;
       $this->notify();
   }

   public function getNews()
   {
       return $this->news;
   }
}

class MailSubscriber implements SplObserver
{
   private $email;

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

   public function update(SplSubject $subject)
   {
       echo "Mail sent to ".$this->email." with news: ".$subject->getNews()."\n";
   }
}

$publisher = new NewsPublisher();

$subscriber1 = new MailSubscriber('subscriber1@example.com');
$subscriber2 = new MailSubscriber('subscriber2@example.com');
$subscriber3 = new MailSubscriber('subscriber3@example.com');

$publisher->attach($subscriber1);
$publisher->attach($subscriber2);
$publisher->attach($subscriber3);

$publisher->publish('Breaking news!');

$publisher->detach($subscriber3);

$publisher->publish('Another breaking news!');

The above introduces the differences between common PHP design patterns. I hope readers can better understand and master the application of design patterns. In actual development, design patterns should be used flexibly according to the needs of the project to improve the reusability, maintainability and scalability of the software.

The above is the detailed content of An article exploring the differences between common PHP design patterns. For more information, please follow other related articles on the PHP Chinese website!