设计模式-行为-Observer（观察者）模式

观察者模式（Observer Pattern）是典型的行为型设计模式，MVC 架构就是其经典应用。它定义了一对多的依赖关系：当一个对象的状态发生改变时，所有依赖它的对象都会收到通知并自动更新。

适用场景

• 场景1：观看电视频道——观众主动订阅感兴趣的频道，频道有内容时通知订阅者。
• 场景2：消息订阅——订阅自己关心的状态，当该状态的消息到达时自动得到通知。

缺点

• 每次状态变更都需要广播，并逐一筛选合适的观察者，在观察者数量较多时开销较大。

例1：C++ 基础实现

头文件
#include "PublicHeaders.h"


#include <vector>
#include <string>

class Observer;

class Subject
{
public:
	virtual void Attach(Observer*) = 0;
	virtual void Detach(Observer*) = 0;
	virtual void Notify() = 0;

	void setState(const std::string&state)
	{
		this->_state = state;
	}
	const std::string& getState()const
	{
		return _state;
	}
private:
	std::string _state;
protected:

	std::vector<Observer*> _observers;

};


class ConCreateSubject :public Subject
{
public:
	virtual void Attach(Observer*) override;
	virtual void Detach(Observer*)override;
	virtual void Notify() override;


};

class  Observer
{
public:
	virtual void Update(const std::string &state) = 0;
};

class ConCreateObserverA :public Observer
{
public:
	virtual void Update(const std::string& state)override
	{
		if (state == "A")
		{
			cout << __FUNCTION__ << endl;
		}
	}
};


class ConCreateObserverB :public Observer
{
public:
	virtual void Update(const std::string& state)override
	{
		if (state == "B")
		{
			cout << __FUNCTION__ << endl;
		}
	}
};


void testObserver();



源文件
#include "Observer.h"

void ConCreateSubject::Attach(Observer*observer)
{
	_observers.push_back(observer);
}

void ConCreateSubject::Detach(Observer*observer)
{
	auto iter = std::find(_observers.begin(), _observers.end(), observer);
	if (iter != _observers.end())
	{
		_observers.erase(iter);
	}

}

void ConCreateSubject::Notify()
{
	for (int i = 0; i < _observers.size(); ++i)
	{
		_observers[i]->Update(this->getState());
	}
}




void testObserver()
{
	ConCreateSubject *sub = new ConCreateSubject;

	auto a1 = new ConCreateObserverA;
	sub->Attach(a1);

	auto a2 = new ConCreateObserverA;
	sub->Attach(a2);

	auto b1 = new ConCreateObserverB;
	sub->Attach(b1);

	sub->setState("A");

	sub->Notify();

	sub->Detach(a1);


	sub->Notify();

}

例2：Unity C# 游戏中的观察者实例

以下是在游戏中实现的观察者中心（NotifyCenter）示例。

using UnityEngine;
using System.Collections;
using System.Collections.Generic;


public delegate void HandlerNotifyCenter(System.Object arg);



[System.Serializable]
class Recver
{

    public string name;
    public GameObject recver;

    public HandlerNotifyCenter handler;
    public Recver()
    {


    }

    public void InVoke(System.Object arg)
    {
        handler(arg);
    }
}


public class NotifyCenter : MonoBehaviour
{
    static public NotifyCenter ins;

    List<Recver> recvers = new List<Recver>();



    void Awake()
    {
        ins = this;
    }
    // Use this for initialization
    void Start()
    {

    }

    // Update is called once per frame
    void Update()
    {

    }



    public void addRecver(GameObject recver, string name, HandlerNotifyCenter handler)
    {
        // gameObject.SendMessage(msg);

        Recver x = new Recver();
        x.name = name;
        x.handler = handler;
        x.recver = recver;
        recvers.Add(x);
    }


    public void removeRecver(GameObject recver, string name)
    {
        foreach (Recver obj in recvers)
        {
            if (name == obj.name && recver == obj.recver)
            {
                recvers.Remove(obj);
            }
        }



    }

    public void sendMessage(string msg, System.Object arg)
    {
        foreach (Recver obj in recvers)
        {
            if (msg == obj.name)
            {
                obj.InVoke(arg);
            }
        }
    }

}



添加观察者
    NotifyCenter x = NotifyCenter.ins;
    x.addRecver(gameObject, "addCoin", new HandlerNotifyCenter(addCoin));
    public void addCoin(System.Object obj)
    {


    }

例3：C++ 基于 unordered_map 的简化实现

class NotifyCenter
{
public:
	static NotifyCenter *ins;
	static NotifyCenter*getInstance()
	{
		if (ins == nullptr)
		{
			ins = new NotifyCenter;
		}
		return ins;
	}

	void SendMessage(string name, void* data)
	{
		auto &func = _listeners[name];
		if (func )
		{
			func(data);
		}
	}

	void addListener(string name, std::function<void(void*data)>  callback)
	{
		_listeners[name] = callback;
	}


private:
	std::unordered_map<  string, std::function<void(void*data)>  >  _listeners;

};

NotifyCenter*NotifyCenter::ins = nullptr;



int main()
{

	//添加接受者
	NotifyCenter::getInstance()->addListener("john", [=](void *data)
	{//回调

		cout << (char*)data<<"   call me " << endl;
	});

	//添加接受者

	NotifyCenter::getInstance()->addListener("jack", [=](void *data)
	{
		//回调

		cout << (char*)data << "   call me " << endl;
	});


	//发送消息
	NotifyCenter::getInstance()->SendMessage("john","hk");

	//发送消息
	NotifyCenter::getInstance()->SendMessage("john", "");

	//发送消息
	NotifyCenter::getInstance()->SendMessage("11", "");


	system("pause");

	return 0;
}

当然用 vector 也可以实现一对多的观察者通知。