Home >Backend Development >PHP Tutorial >PHP design pattern Observer pattern example introduction_PHP tutorial
PHP design pattern Observer pattern example introduction_PHP tutorial
- WBOYOriginal
- 2016-07-13 10:34:27900browse
This article mainly introduces the detailed introduction and code examples of the Observer pattern (Observer) in PHP design patterns. Friends in need can refer to it
【Intention】
Define a one-to-many dependency relationship between objects. When the state of an object changes, all objects that depend on it are notified and automatically updated [GOF95], also known as publish-subscribe (Publish- Subscribe) mode, Model-View (Model-View) mode, Source-Listener (Source-Listener) mode, or Dependents (Dependents) mode
[Observer Pattern Structure Diagram]
【Main role in observer mode】
1. Abstract subject (Subject) role: The subject role saves all references to observer objects in a collection, and each subject can have any number of observers. The abstract theme provides an interface for adding and removing observer objects.
2. Abstract Observer (Observer) role: Define an interface for all specific observers and update themselves when the subject of observation changes.
3. Concrete Subject (ConcreteSubject) role: Store relevant states to specific observer objects. When the internal state of the specific subject changes, a notification is sent to all registered observers. Concrete theme roles are usually implemented using a concrete subclass.
4. Concrete Observer role: Store a specific subject object, store related states, and implement the update interface required by the abstract observer role to make its own state consistent with the state of the subject.
【Advantages and Disadvantages of Observer Mode】
Advantages of Observer Pattern:
1. The coupling between the observer and the subject is small;
2. Support broadcast communication;
Disadvantages of Observer Pattern:
Since the observer is unaware of the existence of other observers, it may not know the ultimate cost of changing the target. This may cause unexpected updates.
[Applicable scenarios for observer mode]
When an abstract model has two aspects, one of which depends on the other.
When changes to one object require changes to other objects at the same time, it is not known how many objects need to be changed.
When an object must notify other objects, it cannot assume who the other objects are. In other words, you don't want these objects to be tightly coupled.
【Observer Mode and Other Modes】
1. Mediator pattern (Mediator): By encapsulating complex update semantics, ChangeManager acts as a mediator between the target and the observer.
2. Singleton mode (singleton mode): ChangeManager can use the Singleton mode to ensure that it is unique and globally accessible.
【Observer Mode PHP Example】
The code is as follows:
/**
* Observer Mode
* @package design pattern
*/
/**
* Abstract theme characters
*/
interface Subject {
/**
* Add a new observer object
* @param Observer $observer
*/
public function attach(Observer $observer);
/**
* Delete a registered observer object
* @param Observer $observer
*/
public function detach(Observer $observer);
/**
* Notify all registered observer objects
*/
public function notifyObservers();
}
/**
* Specific theme roles
*/
class ConcreteSubject implements Subject {
private $_observers;
public function __construct() {
$this->_observers = array();
}
/**
* Add a new observer object
* @param Observer $observer
*/
public function attach(Observer $observer) {
return array_push($this->_observers, $observer);
}
/**
* Delete a registered observer object
* @param Observer $observer
*/
public function detach(Observer $observer) {
$index = array_search($observer, $this->_observers);
if ($index === FALSE || ! array_key_exists($index, $this->_observers)) {
return FALSE;
}
unset($this->_observers[$index]);
return TRUE;
}
/**
* Notify all registered observer objects
*/
public function notifyObservers() {
if (!is_array($this->_observers)) {
return FALSE;
}
foreach ($this->_observers as $observer) {
$observer->update();
}
return TRUE;
}
}
/**
* Abstract observer role
*/
interface Observer {
/**
* Update method
*/
public function update();
}
class ConcreteObserver implements Observer {
/**
* The name of the observer
* @var
*/
private $_name;
public function __construct($name) {
$this->_name = $name;
}
/**
* Update method
*/
public function update() {
echo 'Observer', $this->_name, ' has notified.
';
}
}
实例化类：
$subject = new ConcreteSubject();
/* 添加第一个观察者 */
$observer1 = new ConcreteObserver('Martin');
$subject->attach($observer1);
echo '
The First notify:
';
$subject->notifyObservers();
/* 添加第二个观察者 */
$observer2 = new ConcreteObserver('phppan');
$subject->attach($observer2);
echo '
The Second notify:
';
$subject->notifyObservers();
/* 删除第一个观察者 */
$subject->detach($observer1);
echo '
The Third notify:
';
$subject->notifyObservers();
具体案例：
/**
* 3.1php设计模式-观测者模式
* 3.1.1概念:其实观察者模式这是一种较为容易去理解的一种模式吧，它是一种事件系统，意味
* 着这一模式允许某个类观察另一个类的状态，当被观察的类状态发生改变的时候，
* 观察类可以收到通知并且做出相应的动作;观察者模式为您提供了避免组件之间
* 紧密耦合的另一种方法
* 3.1.2关键点:
* 1.被观察者->追加观察者;->一处观察者;->满足条件时通知观察者;->观察条件
* 2.观察者 ->接受观察方法
* 3.1.3缺点:
* 3.1.4观察者模式在PHP中的应用场合:在web开发中观察者应用的方面很多
* 典型的:用户注册(验证邮件，用户信息激活)，购物网站下单时邮件/短信通知等
* 3.1.5php内部的支持
* SplSubject 接口，它代表着被观察的对象，
* 其结构：
* interface SplSubject
* {
* public function attach(SplObserver $observer);
* public function detach(SplObserver $observer);
* public function notify();
* }
* SplObserver 接口，它代表着充当观察者的对象，
* 其结构：
* interface SplObserver
* {
* public function update(SplSubject $subject);
* }
*/
/**
* User login - Interpretation of observer mode
*/
class User implements SplSubject {
//注册观察者
public $observers = array();
//动作类型
CONST OBSERVER_TYPE_REGISTER = 1;//注册
CONST OBSERVER_TYPE_EDIT = 2;//编辑
/**
* Add observers
* @param SplObserver $observer Observer
* @param int $type observation type
*/
public function attach(SplObserver $observer, $type)
{
$this->observers[$type][] = $observer;
}
/**
* Remove observers
* @param SplObserver $observer Observer
* @param int $type observation type
*/
public function detach(SplObserver $observer, $type)
{
if($idx = array_search($observer, $this->observers[$type], true))
{
unset($this->observers[$type][$idx]);
}
}
/**
* Notify observers when conditions are met
* @param int $type observation type
*/
public function notify($type)
{
if(!empty($this->observers[$type]))
{
foreach($this->observers[$type] as $observer)
{
$observer->update($this);
}
}
}
/**
* Add user
* @param str $username Username
* @param str $password Password
* @param str $email Email
* @return bool
*/
public function addUser()
{
//执行sql
//数据库插入成功
$res = true;
//调用通知观察者
$this->notify(self::OBSERVER_TYPE_REGISTER);
return $res;
}
/**
* User information editing
* @param str $username Username
* @param str $password Password
* @param str $email Email
* @return bool
*/
public function editUser()
{
//执行sql
//数据库更新成功
$res = true;
//调用通知观察者
$this->notify(self::OBSERVER_TYPE_EDIT);
return $res;
}
}
/**
* Observer-Send Email
*/
class Send_Mail implements SplObserver
{
/**
* Change information of the corresponding observed object
* @param SplSubject $subject
*/
public function update(SplSubject $subject)
{
$this->sendMail($subject->email, $title, $content);
}
/**
*Send email
*@param str $email Email address
*@param str $title Email title
*@param str $content Email content
*/
public function sendEmail($email, $title, $content)
{
//Call the email interface and send email
}
}
?>