Detailed introduction and code examples of PHP design pattern Observer pattern_PHP tutorial

【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. Supports 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]

Copy code The code is as follows:

/**
* 观察者模式
* @package design pattern
*/

/**
* 抽象主题角色
*/
interface Subject {

/**
* 增加一个新的观察者对象
* @param Observer $observer
*/
public function attach(Observer $observer);

/**
* 删除一个已注册过的观察者对象
* @param Observer $observer
*/
public function detach(Observer $observer);

/**
* 通知所有注册过的观察者对象
*/
public function notifyObservers();
}

/**
* 具体主题角色
*/
class ConcreteSubject implements Subject {

private $_observers;

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

    /**
     * 增加一个新的观察者对象
     * @param Observer $observer
     */
    public function attach(Observer $observer) {
        return array_push($this->_observers, $observer);
    }

    /**
     * 删除一个已注册过的观察者对象
     * @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;
    }

    /**
     * 通知所有注册过的观察者对象
     */
    public function notifyObservers() {
        if (!is_array($this->_observers)) {
            return FALSE;
        }

        foreach ($this->_observers as $observer) {
            $observer->update();
        }

        return TRUE;
    }

}

/**
* 抽象观察者角色
*/
interface Observer {

    /**
     * 更新方法
     */
    public function update();
}

class ConcreteObserver implements Observer {

    /**
     * 观察者的名称
     * @var
     */
    private $_name;

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

    /**
     * 更新方法
     */
    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);
  *        }
  */

 /**
  * 用户登陆-诠释观察者模式
  */
class User implements SplSubject {
    //注册观察者
    public $observers = array();

    //动作类型
    CONST OBSERVER_TYPE_REGISTER = 1;//注册
    CONST OBSERVER_TYPE_EDIT = 2;//编辑

    /**
     * 追加观察者
     * @param SplObserver $observer 观察者
     * @param int $type 观察类型
     */
    public function attach(SplObserver $observer, $type)
    {
        $this->observers[$type][] = $observer;
    }

    /**
     * 去除观察者
     * @param SplObserver $observer 观察者
     * @param int $type 观察类型
     */
    public function detach(SplObserver $observer, $type)
    {
        if($idx = array_search($observer, $this->observers[$type], true))
        {
            unset($this->observers[$type][$idx]);
        }
    }

    /**
     * 满足条件时通知观察者
     * @param int $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()
{

//Execute sql

//Database insertion successful

//Calling the notification observer

$this->notify(self::OBSERVER_TYPE_REGISTER);

return $res;

}

/**

* User information editing
* @param str $username Username
* @param str $password Password
* @param str $email Email address
* @return bool
*/
public function editUser()
{

//Execute sql

//Database updated successfully

$res = true;

//Call the notification observer

$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
}
}
?>

http://www.bkjia.com/PHPjc/750852.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/750852.htmlTechArticle[Intent] 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...