Explication détaillée du modèle de conception PHPModèle d'observateur

Résumé : Les événements Yii2 adoptent le "mode observateur". Il est plus facile de comprendre d'abord l'observateur puis d'apprendre les événements.

Qu'est-ce que c'est

Tout d'abord, ne vous laissez pas intimider par le nom, continuez à lire, c'est vraiment simple.

Commençons par une définition de niveau supérieur : le modèle d'observateur définit une relation un-à-plusieurs entre une série d'objets. Lorsqu'un objet change d'état, les autres dépendants recevront des notifications.

Vous comprenez ?

Si vous ne comprenez pas, essayons quelque chose de plus réaliste : le modèle d'observateur est le modèle de commande de journaux. Vous et certaines personnes commandez des journaux à un certain journal. Tant qu'un nouveau journal est publié, le. Le journal vous le livrera. Ce que vous pensez spécifiquement n'a rien à voir avec le journal. Tant que le journal ne fermera pas ses portes, il continuera à vous l'envoyer.

Bien sûr, vous pouvez également vous désinscrire.

Mode observateur == journal + abonné au journal

Peu importe la définition que vous comprenez, rappelez-vous une chose, le "mode observateur" est le plus génial L'endroit est de coupler vaguement certaines classes qui dépendent les unes des autres. À quoi ressemble un bon système ? Autrement dit, le degré de dépendance entre chaque objet est réduit à un point de congélation, mais l'interaction est toujours possible.

Codez-le

Je pense qu'à ce stade, vous avez déjà compris le modèle d'observateur, mais en tant qu'article linguistique, il ne peut pas être justifié sans écrire du code. Utilisons du code pour répondre aux exigences ci-dessus.

Commençons par un code qui n'utilise pas le modèle observateur

class Video {    public function new(){
        $checkNewVideo = Video::find()->where("xxxxx")->one();        if($checkNewVideo){            //    通知各位
            LaoWang::newVideo();
            XiaoLi::newVideo();
            ChuanPu::newVideo();
            .......            //    还有很多很多，比如在给某个集体客户群发、短信发等等等等
        }
    }
}//    具体实现$model = new Video();
$model->new();

En fait, lorsque le système est petit, c'est un moyen très rapide et efficace.

Cependant, lorsque le système devient plus grand, cette méthode est immédiatement confrontée au problème d'être difficile à étendre et sujette aux erreurs.

• Par exemple, si Lao Wang ne veut pas s'abonner, nous devons changer le code source.

• Par exemple, si un autre client est ajouté, nous devons modifier le code source.

• Par exemple xxx, nous devons tous changer le code source.

Le couplage entre ces deux objets est trop élevé.

Résolvez-le - utilisez le modèle d'observateur

Améliorons d'abord le code ci-dessus

/**
 * 被观察者接口
 * 定义了一些公用方法声明，使用观察者模式的类都可以继承此接口
 */interface Observable {    // 添加/注册观察者
    public function attach(Observer $observer);    // 删除观察者
    public function detach(Observer $observer);    // 触发通知
    public function notify();
}class Video implements Observable {    public $observers = [];//    订阅者

    //    添加观察者
    public function attach(Observer $observer){
        $key = array_search($observer, $this->observers);        if ($key === false) {            $this->observers[] = $observer;
        }
    }    //    删除观察者
    public function detach(Observer $observer){
        $key = array_search($observer, $this->observers);        if ($key !== false) {            unset($this->observers[$key]);
        }
    }    //    通知所有观察者
    public function notify(){        foreach ($this->observers as $observer) {            // 把本类对象传给观察者
            $observer->update($this);
        }
    }    public function  new(){
        $checkNewVideo = Video::find()->where("xxxxx")->one();        if($checkNewVideo){            $this->notify();
        }
    }
}

Comme vous pouvez le voir, le code modifié ne se soucie pas de savoir à qui est envoyé, Il parcourt simplement la liste de tous les observateurs et leur indique que l'ajout et la suppression d'observateurs n'auront aucun impact sur ce type.

对于观察者，数字不定，随时有增减，因此我们定义了一个观察者接口开始抽象它们。

/**
 * 观察者接口
 */interface Observer{    // 接收到通知的处理方法
    public function update(Observable $observable);
}

老王、小明、川普、冰冰订阅了视频

class LaoWang implements Observer {    public function update(Observable $observable){        echo "立刻开始看视频";
    }
}class XiaoMing implements Observer {    public function update(Observable $observable){        echo "收到后忽略通知";
    }
}class ChuanPu implements Observer {    public function update(Observable $observable){        echo "收藏了一下，然后去wc看";
    }
}class BingBing implements Observer {    public function update(Observable $observable){        echo "立刻开始看视频";
    }
}

具体实现

$model = new Video();
$model->attach(new LaoWang());
$model->attach(new XiaoLi());
$model->attach(new ChuanPu());
$model->attach(new BingBing());
$model->new();

这样当我们再增加一个人加入 习大大 的时候，我们只需要增加一个习大大的观察者类，在实现的时候添加注册，而不需要去改Video类和其他的观察者类，将类之间的耦合降低了很多。

回头看

上面就是观察者模式，我们先预想一下我们的事件，假设我们定义了很多观察者代码，他们监听事件的发生，当一个事件被触发，这些观察者都会知道，执行各自的逻辑。

事件就是观察者模式的一种应用。

监听系统的某一个行为，实时获取并执行自己负责的代码。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!