Detailed explanation of PHP design pattern Observer pattern

Abstract: Yii2 events adopt the "observer mode". It is easier to understand the observer first and then learn the events.

What is it

First of all, don’t be intimidated by the name, look down, it’s really simple.

Let’s start with a more advanced definition: the observer pattern defines a one-to-many relationship between a series of objects. When an object changes state, other dependents will receive notifications.

Do you understand?

If you don’t understand, let’s give you a more realistic idea: the observer model is the model of ordering newspapers. You and some people order newspapers from a certain newspaper. As long as a new newspaper is published, the newspaper will deliver it to you. What you think specifically has nothing to do with the newspaper. As long as the newspaper doesn't close down, it will continue to send it to you.

Of course, you can also unsubscribe.

Observer Mode== Newspaper + People who subscribe to newspapers

No matter which definition you understand, remember one thing, "Observer Mode" is the most awesome The place is to loosely couple some classes that depend on each other. What does a great system look like? That is, the degree of dependence between each object is reduced to a freezing point, but interaction is still possible.

Code it

I think at this moment, you have already understood the observer pattern, but as a language article, it is impossible not to write some code. Let's use code to realize the above requirements.

Let’s start with a code that doesn’t use the observer pattern

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

In fact, when the system is small, this is a very fast and effective way.

However, when the system becomes larger, this method immediately faces the problem of being difficult to expand and prone to errors.

• For example, if Lao Wang no longer wants to subscribe, we need to change the source code.

• For example, if another customer is added, we need to change the source code.

• For example xxx, we all need to change the source code.

The coupling between these two objects is too high.

Solve it - use the observer pattern

Let’s improve the above code first

/**
 * 被观察者接口
 * 定义了一些公用方法声明，使用观察者模式的类都可以继承此接口
 */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();
        }
    }
}

As you can see, the modified code does not care about who is sent to, it just It traverses the list of all observers and then tells them. The increase or decrease of observers will not have any impact on this 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类和其他的观察者类，将类之间的耦合降低了很多。

回头看

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

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

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

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