This article gives you a brief introduction to the three most commonly used design patterns in PHP: singleton design pattern, factory design pattern and observer design pattern. These are all personal experience summaries. I hope you guys will like them.
This article is a note and summary of the three design patterns commonly used in PHP. No matter which language is used to develop something, almost all of them will be used. Coming to design patterns, why do we need design patterns? What role and significance does its birth have for us developers?
I believe those who develop iOS will be familiar with design patterns, right? For example, singleton design pattern, factory design pattern, Observer pattern, MVC framework design pattern, etc.
Next, let’s learn the three most commonly used design patterns in PHP: singleton design pattern, factory design pattern and observer design pattern.
Single case design pattern
The so-called Single case pattern means that at most one instance of this class exists in the application. Once created, It will always exist in the memory!
The singleton design pattern is often used in database class design. The singleton pattern is used to connect to the database only once to prevent multiple database connections from being opened.
A singleton class should have the following characteristics:
A singleton class cannot be directly instantiated and created, but can only be instantiated by the class itself. Therefore, to obtain such a restrictive effect, the constructor must be marked private, thus preventing the class from being instantiated.
Requires a private static member variable to save the class instance and expose a public static method that can access the instance.
In PHP, in order to prevent others from cloning singleton class instances, an empty private clone() method is usually provided for it.
Example of singleton pattern:
<?php
/**
* Singleton of Database
*/
class Database
{
// We need a static private variable to store a Database instance.
privatestatic $instance;
// Mark as private to prevent it from being instanced.
privatefunctionconstruct()
{
// Do nothing.
}
privatefunctionclone()
{
// Do nothing.
}
publicstatic functiongetInstance()
{
if (!(self::$instanceinstanceofself)) {
self::$instance = newself();
}
returnself::$instance;
}
}
$a =Database::getInstance();
$b =Database::getInstance();
// true
var_dump($a === $b);Copy after login
Factory design pattern
Factory design pattern is often used based on different input parameters or different application configurations to create an instance specifically designed to instantiate and return its corresponding class.
Let’s take an example. Assume that rectangle and circle have the same method. Then when we use the API provided by the base class to create an instance, we will automatically create an instance of the corresponding class by passing parameters. They all have access to Functions of perimeter and area.
<?php
interfaceInterfaceShape
{
functiongetArea();
functiongetCircumference();
}
/**
* 矩形
*/
class Rectangle implementsInterfaceShape
{
private $width;
private $height;
publicfunctionconstruct($width, $height)
{
$this->width = $width;
$this->height = $height;
}
publicfunctiongetArea()
{
return $this->width* $this->height;
}
publicfunctiongetCircumference()
{
return 2 * $this->width + 2 * $this->height;
}
}
/**
* 圆形
*/
class Circle implementsInterfaceShape
{
private $radius;
functionconstruct($radius)
{
$this->radius = $radius;
}
publicfunctiongetArea()
{
return M_PI * pow($this->radius, 2);
}
publicfunctiongetCircumference()
{
return 2 * M_PI * $this->radius;
}
}
/**
* 形状工厂类
*/
class FactoryShape
{
publicstatic functioncreate()
{
switch (func_num_args()) {
case1:
return newCircle(func_get_arg(0));
case2:
return newRectangle(func_get_arg(0), func_get_arg(1));
default:
# code...
break;
}
}
}
$rect =FactoryShape::create(5, 5);
// object(Rectangle)#1 (2) { ["width":"Rectangle":private]=> int(5) ["height":"Rectangle":private]=> int(5) }
var_dump($rect);
echo "<br>";
// object(Circle)#2 (1) { ["radius":"Circle":private]=> int(4) }
$circle =FactoryShape::create(4);
var_dump($circle);Copy after login
Observer design pattern
The observer pattern is a very common design pattern. If used properly, it will bring great convenience to the program. If used improperly, it will bring great convenience to the program. , will give later generations an idea that is difficult to maintain.
What is the observer pattern? An object makes itself observable by providing methods that allow another object, an observer, to register itself). When an observable object changes, it sends messages to registered observers. These observers use this information to perform operations independent of the observable object. The result is that objects can talk to each other without having to understand why. The observer pattern is an event system, which means that this pattern allows a class to observe the state of another class. When the state of the observed class changes, the observing class can receive notifications and take corresponding actions; observation The operator pattern provides you with the ability to avoid tight coupling between components. You will understand after looking at the example below!
<?php
/*
观察者接口
*/
interfaceInterfaceObserver
{
functiononListen($sender, $args);
functiongetObserverName();
}
// 可被观察者接口
interfaceInterfaceObservable
{
functionaddObserver($observer);
functionremoveObserver($observer_name);
}
// 观察者抽象类
abstractclass Observer implementsInterfaceObserver
{
protected $observer_name;
functiongetObserverName()
{
return $this->observer_name;
}
functiononListen($sender, $args)
{
}
}
// 可被观察类
abstractclass Observable implementsInterfaceObservable
{
protected $observers = array();
publicfunctionaddObserver($observer)
{
if ($observerinstanceofInterfaceObserver)
{
$this->observers[] = $observer;
}
}
publicfunctionremoveObserver($observer_name)
{
foreach ($this->observersas $index => $observer)
{
if ($observer->getObserverName() === $observer_name)
{
array_splice($this->observers, $index, 1);
return;
}
}
}
}
// 模拟一个可以被观察的类
class A extendsObservable
{
publicfunctionaddListener($listener)
{
foreach ($this->observersas $observer)
{
$observer->onListen($this, $listener);
}
}
}
// 模拟一个观察者类
class B extendsObserver
{
protected $observer_name = 'B';
publicfunctiononListen($sender, $args)
{
var_dump($sender);
echo "<br>";
var_dump($args);
echo "<br>";
}
}
// 模拟另外一个观察者类
class C extendsObserver
{
protected $observer_name = 'C';
publicfunctiononListen($sender, $args)
{
var_dump($sender);
echo "<br>";
var_dump($args);
echo "<br>";
}
}
$a = new A();
// 注入观察者
$a->addObserver(new B());
$a->addObserver(new C());
// 可以看到观察到的信息
$a->addListener('D');
// 移除观察者
$a->removeObserver('B');
// 打印的信息：
// object(A)#1 (1) { ["observers":protected]=> array(2) { [0]=> object(B)#2 (1) { ["observer_name":protected]=> string(1) "B" } [1]=> object(C)#3 (1) { ["observer_name":protected]=> string(1) "C" } } }
// string(1) "D"
// object(A)#1 (1) { ["observers":protected]=> array(2) { [0]=> object(B)#2 (1) { ["observer_name":protected]=> string(1) "B" } [1]=> object(C)#3 (1) { ["observer_name":protected]=> string(1) "C" } } }
// string(1) "D"Copy after login
The above is the detailed content of Introducing three commonly used design patterns in PHP: singleton design pattern, factory design pattern and observer design pattern.. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
