1. <?php
    3. //spl standard php library
    5. /**
    6.  * PHP has a couple of built-in interfaces related to the Observer pattern.
    7.  *
    8.  * Here's what the Subject interface looks like:
    9.  *
    10.  * @link http://php.net/manual/en/class.splsubject.php
    11.  *
    12.  *     interface SplSubject
    13.  *     {
    14.  *         // Attach an observer to the subject.
    15.  *         public function attach(SplObserver $observer);
    16.  *
    17.  *         // Detach an observer from the subject.
    18.  *         public function detach(SplObserver $observer);
    19.  *
    20.  *         // Notify all observers about an event.
    21.  *         public function notify();
    22.  *     }
    23.  *
    24.  * There's also a built-in interface for Observers:
    25.  *
    26.  * @link http://php.net/manual/en/class.splobserver.php
    27.  *
    28.  *     interface SplObserver
    29.  *     {
    30.  *         public function update(SplSubject $subject);
    31.  *     }
    32.  */
    34. /**
    35.  * The Subject owns some important state and notifies observers when the state
    36.  * changes.
    37.  */
    38. class Subject implements \SplSubject
    39. {
    40.     /**
    41.      * @var int For the sake of simplicity, the Subject's state, essential to
    42.      * all subscribers, is stored in this variable.
    43.      */
    44.     public $state;
    46.     /**
    47.      * @var \SplObjectStorage List of subscribers. In real life, the list of
    48.      * subscribers can be stored more comprehensively (categorized by event
    49.      * type, etc.).
    50.      */
    51.     private $observers;
    53.     public function __construct()
    54.     {
    55.         $this->observers = new \SplObjectStorage();
    56.     }
    58.     /**
    59.      * The subscription management methods.
    60.      */
    61.     public function attach(\SplObserver $observer): void
    62.     {
    63.         echo "Subject: Attached an observer.\n";
    64.         $this->observers->attach($observer);
    65.     }
    67.     public function detach(\SplObserver $observer): void
    68.     {
    69.         $this->observers->detach($observer);
    70.         echo "Subject: Detached an observer.\n";
    71.     }
    73.     /**
    74.      * Trigger an update in each subscriber.
    75.      */
    76.     public function notify(): void
    77.     {
    78.         echo "Subject: Notifying observers...\n";
    79.         foreach ($this->observers as $observer) {
    80.             $observer->update($this);
    81.         }
    82.     }
    84.     /**
    85.      * Usually, the subscription logic is only a fraction of what a Subject can
    86.      * really do. Subjects commonly hold some important business logic, that
    87.      * triggers a notification method whenever something important is about to
    88.      * happen (or after it).
    89.      */
    90.     public function someBusinessLogic(): void
    91.     {
    92.         echo "\nSubject: I'm doing something important.\n";
    93.         $this->state = rand(0, 10);
    95.         echo "Subject: My state has just changed to: {$this->state}\n";
    96.         $this->notify();
    97.     }
    98. }
    100. /**
    101.  * Concrete Observers react to the updates issued by the Subject they had been
    102.  * attached to.
    103.  */
    104. class ConcreteObserverA implements \SplObserver
    105. {
    106.     public function update(\SplSubject $subject): void
    107.     {
    108.         if ($subject->state < 3) {
    109.             echo "ConcreteObserverA: Reacted to the event.\n";
    110.         }
    111.     }
    112. }
    114. class ConcreteObserverB implements \SplObserver
    115. {
    116.     public function update(\SplSubject $subject): void
    117.     {
    118.         if ($subject->state == 0 || $subject->state >= 2) {
    119.             echo "ConcreteObserverB: Reacted to the event.\n";
    120.         }
    121.     }
    122. }
    124. /**
    125.  * The client code.
    126.  */
    128. $subject = new Subject();
    130. $o1 = new ConcreteObserverA();
    131. $subject->attach($o1);
    133. $o2 = new ConcreteObserverB();
    134. $subject->attach($o2);
    136. $subject->someBusinessLogic();
    137. $subject->someBusinessLogic();
    139. $subject->detach($o2);
    141. $subject->someBusinessLogic();

    输出

    1. Subject: Attached an observer.
    2. Subject: Attached an observer.
    4. Subject: I'm doing something important.
    5. Subject: My state has just changed to: 8
    6. Subject: Notifying observers...
    7. ConcreteObserverB: Reacted to the event.
    9. Subject: I'm doing something important.
    10. Subject: My state has just changed to: 0
    11. Subject: Notifying observers...
    12. ConcreteObserverA: Reacted to the event.
    13. ConcreteObserverB: Reacted to the event.
    14. Subject: Detached an observer.
    16. Subject: I'm doing something important.
    17. Subject: My state has just changed to: 1
    18. Subject: Notifying observers...
    19. ConcreteObserverA: Reacted to the event.