PHP design patterns: singleton mode, factory mode and observer mode

This article introduces the three modes in PHP design patterns, namely singleton mode, factory mode and observer mode. Friends in need can refer to it.

One, Single case mode

Only one instance of this class will exist in the application. For example, the singleton mode only allows one object to access the database, thus preventing multiple database connections from being opened.

A singleton class should include the following points: Unlike ordinary classes, singleton classes cannot be instantiated directly, but can only be instantiated by themselves. Therefore, to obtain such restrictive effects, the constructor must be marked private. For a singleton class to function without being instantiated directly, such an instance must be provided for it. Therefore, it is necessary for the singleton class to have a private static member variable that can save the instance of the class and a corresponding one that can access the actual Public static method of example.

In PHP, in order to prevent the cloning of the singleton class object from breaking the above implementation form of the singleton class, an empty private __clone() method is usually provided for the base.

A basic singleton pattern:

<?php
class SingetonBasic {
private static $instance;

// other vars..

private function __construct() {
// do construct..
}

private function __clone() {}

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

// other functions..
}

$a = SingetonBasic::getInstance();
$b = SingetonBasic::getInstance();
var_dump($a === $b);
?>

Two, Factory mode Factory mode allows you to create a class specifically designed to implement and return instances of other classes based on input parameters or application configuration.

A most basic factory pattern:

<?php
class FactoryBasic {
public static function create($config) {
}
}
?>

A factory that describes shape objects. It hopes to create different shapes based on the number of parameters passed in.

<?php
// 定义形状的公共功能：获取周长和面积。
interface IShape {
function getCircum();
function getArea();
}
// 定义矩形类
class Rectangle implements IShape {
private $width, $height;

public function __construct($width, $height) {
$this->width = $width;
$this->height = $height;
}

public function getCircum() {
return 2 * ($this->width + $this->height);
}

public function getArea() {
return $this->width * $this->height;
}
}

// 定义圆类
class Circle implements IShape {
private $radii;

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

public function getCircum() {
return 2 * M_PI * $this->radii;
}

public function getArea() {
return M_PI * pow($this->radii, 2);
}
}

// 根据传入的参数个数不同来创建不同的形状。
class FactoryShape {
public static function create() {
switch (func_num_args()) {
case 1:
return new Circle(func_get_arg(0));
break;
case 2:
return new Rectangle(func_get_arg(0), func_get_arg(1));
break;

}
}
}

// 矩形对象
$c = FactoryShape::create(4, 2);
var_dump($c->getArea());
// 圆对象
$o = FactoryShape::create(2);
var_dump($o->getArea());
?>

Instructions: The factory pattern makes it easier to call methods, because it has only one class and one method. If the factory pattern is not used, you have to decide which class and which method should be called when calling; using the factory pattern also makes future correspondence It is easier to make changes using a program. For example, to add support for a shape, you only need to modify the create() method in the factory class. If you do not use the factory pattern, you need to modify the code block that calls the shape.

Three, Observer mode The Observer pattern provides another way to avoid tight coupling between components. The pattern is simple: an object makes itself observable by adding a method that allows another object, the 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.

A simple example of observer pattern: When a listener listens to the station (that is, when a new listener is added to the station), it will send out an alert message that can be observed by the log observer who sent the message.

<?php
// 观察者接口
interface IObserver {
function onListen($sender, $args);
function getName();
}

// 可被观察接口
interface IObservable {
function addObserver($observer);
function removeObserver($observer_name);
}

// 观察者类
abstract class Observer implements IObserver {
protected $name;

public function getName() {
return $this->name;
}
}

// 可被观察类
class Observable implements IObservable {
protected $observers = array();

public function addObserver($observer) {
if (!($observer instanceof IObserver)) {
return;
}
$this->observers[] = $observer;
}

public function removeObserver($observer_name) {
foreach ($this->observers as $index => $observer) {
if ($observer->getName() === $observer_name) {
array_splice($this->observers, $index, 1);
return;
}
}
}
}

// 模拟一个可以被观察的类：RadioStation
class RadioStation extends Observable {

public function addListener($listener) {
foreach ($this->observers as $observer) {
$observer->onListen($this, $listener);
}
}
}

// 模拟一个观察者类
class RadioStationLogger extends Observer {
protected $name = 'logger';

public function onListen($sender, $args) {
echo $args, ' join the radiostation.
';
}
}

// 模拟另外一个观察者类
class OtherObserver extends Observer {
protected $name = 'other';
public function onListen($sender, $args) {
echo 'other observer..
';
}
}

$rs = new RadioStation();

// 注入观察者
$rs->addObserver(new RadioStationLogger());
$rs->addObserver(new OtherObserver());

// 移除观察者
$rs->removeObserver('other');

// 可以看到观察到的信息
$rs->addListener('cctv');
?>