Detailed explanation of php observer pattern

This article mainly introduces the detailed explanation of the PHP observer mode. Interested friends can refer to it. I hope it will be helpful to everyone.

1. Intention
Define a one-to-many dependency relationship between objects. When the state of an object changes, all objects that depend on it All objects 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 slave Dependents pattern
2. Observer pattern structure diagram

#3. The main role in the observer patternAbstract subject (Subject) role:The subject role saves all references to the observer object in a collection, each subject There can be any number of observers. The abstract theme provides an interface for adding and removing observer objects.
Abstract Observer (Observer) role: Define an interface for all specific observers and update themselves when the subject of observation changes.
Concrete subject (ConcreteSubject) role: Store the relevant state to the specific observer object. When the internal state of the specific subject changes, notify all registered observers. Concrete theme roles are usually implemented using a concrete subclass.
Concrete Observer (ConcretedObserver) 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.
4. Advantages and disadvantages of the observer pattern
Advantages of the observer pattern:1. The degree of coupling between the observer and the subject Smaller; 2. Supports broadcast communication;
Disadvantages of the observer mode:
1. Since the observer does not know the existence of other observers, it may have a negative impact on the final cost of changing the target. Nothing is known. This may cause unexpected updates.
5. Applicable scenarios of the observer pattern1. When an abstract model has two aspects, one of which depends on the other. 2. When changing one object requires changing other objects at the same time, it is not known how many objects need to be changed. 3. 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.


6. Observer pattern and other patternsMediator pattern (Mediator):By encapsulating complex update semantics, ChangeManager acts as a target and an observer. intermediary between. Singleton mode (singleton mode):
ChangeManager can use the Singleton mode to ensure that it is unique and globally accessible.
7. Observer Mode PHP Example

<?php
/**
 * 抽象主题角色
 */
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 <type>
   */
  private $_name;
 
  public function __construct($name) {
    $this->_name = $name;
  }
 
  /**
   * 更新方法
   */
  public function update() {
    echo &#39;Observer&#39;, $this->_name, &#39; has notified.<br />&#39;;
  }
 
}
 
/**
 * 客户端
 */
class Client {
 
  /**
   * Main program.
   */
  public static function main() {
    $subject = new ConcreteSubject();
 
    /* 添加第一个观察者 */
    $observer1 = new ConcreteObserver(&#39;Martin&#39;);
    $subject->attach($observer1);
 
    echo &#39;<br /> The First notify:<br />&#39;;
    $subject->notifyObservers();
 
    /* 添加第二个观察者 */
    $observer2 = new ConcreteObserver(&#39;phppan&#39;);
    $subject->attach($observer2);
 
    echo &#39;<br /> The Second notify:<br />&#39;;
    $subject->notifyObservers();
 
    /* 删除第一个观察者 */
    $subject->detach($observer1);
 
    echo &#39;<br /> The Third notify:<br />&#39;;
    $subject->notifyObservers();
  }
 
}
 
Client::main();
?>

Summary: The above is the entire content of this article, I hope it will be helpful to everyone's learning.

Related recommendations:

PHP method to implement asterisk to hide username, mobile phone and email address

php WeChat public platform configuration interface development Detailed explanation of the method examples of the program

Detailed explanation of the method of PHP implementation of the previous article and the next article

The above is the detailed content of Detailed explanation of php observer pattern. For more information, please follow other related articles on the PHP Chinese website!