消息机制简单实现模块间解耦-JobPlus

消息机制一直是软件开发中减少模块之间耦合的标准方式，下面我们举一个简单的例子，看看是如何通过消息，减少类 A 和类 B之间的耦合度的。

下面是传统的方法，实现 A 对 B 类的某个方法的调用，不使用消息机制的传统方法，A 需要持有 B 的对象，并且 A 要知道所要调用的B的方法，这样 A 和 B 就强耦合在了一起，一旦 B 类发生变化，A 类就可能要重新编译，而且如果 doSomethingBSpecial 这个方法需要改名，或者修改参数，A 类就也需要修改，这样的依赖关系就带来了诸多的不便。

#include “stdafx.h”
#include <vector>
#include <iostream>
class B
{
public:
void doSomethingBSpecial()
{
//B 做一些事情
std::cout << “B do something…” << std::endl;
}
};
class A
{
public:
A(B* b) :m_b(b){}
void doSomethingASpecial()
{
//在这个方法中，会调用B 的 doSomethingBSpecial
m_b->doSomethingBSpecial();
}
private:
B* m_b;
};
int _tmain(int argc, _TCHAR* argv[])
{
A a(new B());
a.doSomethingASpecial();
return 0;
}

下面使用消息机制实现同样的调用，这样 A 就不需要引用 B 的对象，同时 A 也不需要知道 B 的方法，实现了 A 类和 B 类的解耦。

下面简易的实现了一个的消息处理器，只具备简易的注册，删除和触发事件的功能，在客户的代码中，把 B 的对象注册到消息处理器，使 B 可以处理 doSomethingASpecial 这个消息，然后在 A 类需要调用 B 的方法的地方，可以直接用消息处理器处理 doSomethingASpecial 这个消息，MsgMgr::handle(“doSomethingASpecial”) 这样调用以后，所有注册过 doSomethingASpecial 这个消息的对象（包括 B 对象），都会接受并且处理这个消息，B 对象的 handle 方法就会被调用，然后在这个方法里就可以去调用 B 的 doSomethingBSpecial 方法，这样就实现了 A 对 B类的 doSomethingBSpecial 方法的调用，去掉了 A 和 B 之间的耦合依赖关系。

#include “stdafx.h”
#include <vector>
#include <iostream>
#include <map>
#include <string>
//使用消息机制，A 就不需要持有 B 的对象，
//消息接受者接口
class MsgReceiver
{
public:
virtual void handle() = 0;
};
//这里实现一个简易的消息处理器，只具备简易的，注册，删除，和触发事件的功能
static std::map<std::string, MsgReceiver*> m_allMsgRecevers;
class MsgMgr
{
public:
static void addReceiver(std::string msg, MsgReceiver* receiver)
{
m_allMsgRecevers.emplace(msg, receiver);
}
static void removeReceiver(std::string msg)
{
m_allMsgRecevers.erase(msg);
}
static void handle(std::string msg)
{
m_allMsgRecevers.at(msg)->handle();
}
};
class A
{
public:
void doSomethingASpecial()
{
//这里如果想调用 B 的 doSomethingBSpecial 方法
//可以直接用消息处理器处理 doSomethingASpecial 这个消息
//因为 B 已经注册声明过可以处理 doSomethingASpecial 这个消息
//MsgMgr::handle(“doSomethingASpecial”) 这样调用以后，所有
//注册过 doSomethingASpecial 这个消息的对象，都会接受并且处理这个消息
//这样就去掉了A 和 B之间的耦合依赖关系
MsgMgr::handle(“doSomethingASpecial”);
}
};
class B : public MsgReceiver
{
public:
void doSomethingBSpecial()
{
//B 做一些事情
std::cout << “B do something…” << std::endl;
}
virtual void handle() override
{
doSomethingBSpecial();
}
};
int _tmain(int argc, _TCHAR* argv[])
{
A a;
B* b = new B;
//这里把 B 的对象注册到消息处理器，使 B 可以处理 doSomethingASpecial 这个消息
MsgMgr::addReceiver(“doSomethingASpecial”, b);
a.doSomethingASpecial();
return 0;
}

<p>消息机制一直是软件开发中减少模块之间耦合的标准方式，下面我们举一个简单的例子，看看是如何通过消息，减少类 A 和类 B之间的耦合度的。</p><p>下面是传统的方法，实现 A 对 B 类的某个方法的调用，不使用消息机制的传统方法，A 需要持有 B 的对象，并且 A 要知道所要调用的B的方法，这样 A 和 B 就强耦合在了一起，一旦 B 类发生变化，A 类就可能要重新编译，而且如果 doSomethingBSpecial 这个方法需要改名，或者修改参数，A 类就也需要修改，这样的依赖关系就带来了诸多的不便。</p><table><tbody><tr><td><ol><li>#include “stdafx.h”</li><li>#include <vector></li><li>#include <iostream></li><li>class B</li><li>{</li><li>public:</li><li>    void doSomethingBSpecial()</li><li>    {</li><li>        //B 做一些事情</li><li>        std::cout << “B do something…” << std::endl;</li><li>    }</li><li>};</li><li>class A</li><li>{</li><li>public:</li><li>    A(B* b) :m_b(b){}</li><li>    void doSomethingASpecial()</li><li>    {</li><li>        //在这个方法中，会调用B 的 doSomethingBSpecial</li><li>        m_b->doSomethingBSpecial();</li><li>    }</li><li>private:</li><li>    B* m_b;</li><li>};</li><li>int _tmain(int argc, _TCHAR* argv[])</li><li>{</li><li>    A a(new B());</li><li>    a.doSomethingASpecial();</li><li>    return 0;</li><li>}</li><ol></ol></ol></td></tr></tbody></table><p>下面使用消息机制实现同样的调用，这样 A 就不需要引用 B 的对象，同时 A 也不需要知道 B 的方法，实现了 A 类 和 B 类的解耦。</p><p>下面简易的实现了一个的消息处理器，只具备简易的注册，删除和触发事件的功能，在客户的代码中，把 B 的对象注册到消息处理器，使 B 可以处理 doSomethingASpecial 这个消息，然后在 A 类需要调用 B 的方法的地方， 可以直接用消息处理器处理 doSomethingASpecial 这个消息，MsgMgr::handle(“doSomethingASpecial”) 这样调用以后，所有注册过 doSomethingASpecial 这个消息的对象（包括 B 对象），都会接受并且处理这个消息，B 对象的 handle 方法就会被调用，然后在这个方法里就可以去调用 B 的 doSomethingBSpecial 方法，这样就实现了 A 对 B类的 doSomethingBSpecial 方法的调用， 去掉了 A 和 B 之间的耦合依赖关系。</p><table><tbody><tr><td><ol><li>#include “stdafx.h”</li><li>#include <vector></li><li>#include <iostream></li><li>#include <map></li><li>#include <string></li><li>//使用消息机制，A 就不需要持有 B 的对象，</li><li>//消息接受者接口</li><li>class MsgReceiver</li><li>{</li><li>public:</li><li>    virtual void handle() = 0;</li><li>};</li><li>//这里实现一个简易的消息处理器，只具备简易的，注册，删除，和触发事件的功能</li><li>static std::map<std::string, MsgReceiver*> m_allMsgRecevers;</li><li>class MsgMgr</li><li>{</li><li>public:</li><li>    static void addReceiver(std::string msg, MsgReceiver* receiver)</li><li>    {</li><li>       m_allMsgRecevers.emplace(msg, receiver);</li><li>    }</li><li>    static void removeReceiver(std::string msg)</li><li>    {</li><li>       m_allMsgRecevers.erase(msg);</li><li>    }</li><li>    static void handle(std::string msg)</li><li>    {</li><li>        m_allMsgRecevers.at(msg)->handle();</li><li>    }</li><li>};</li><li>class A</li><li>{</li><li>public:</li><li>    void doSomethingASpecial()</li><li>    {</li><li>        //这里如果想调用 B 的 doSomethingBSpecial 方法</li><li>        //可以直接用消息处理器处理 doSomethingASpecial 这个消息</li><li>        //因为 B 已经注册声明过可以处理 doSomethingASpecial 这个消息</li><li>        //MsgMgr::handle(“doSomethingASpecial”) 这样调用以后，所有</li><li>        //注册过 doSomethingASpecial 这个消息的对象，都会接受并且处理这个消息</li><li>        //这样就去掉了A 和 B之间的耦合依赖关系</li><li>        MsgMgr::handle(“doSomethingASpecial”);</li><li>    }</li><li>};</li><li>class B : public MsgReceiver</li><li>{</li><li>public:</li><li>    void doSomethingBSpecial()</li><li>    {</li><li>        //B 做一些事情</li><li>        std::cout << “B do something…” << std::endl;</li><li>    }</li><li>    virtual void handle() override</li><li>    {</li><li>        doSomethingBSpecial();</li><li>    }</li><li>};</li><li>int _tmain(int argc, _TCHAR* argv[])</li><li>{</li><li>    A a;</li><li>    B* b = new B;</li><li>    //这里把 B 的对象注册到消息处理器，使 B 可以处理 doSomethingASpecial 这个消息</li><li>    MsgMgr::addReceiver(“doSomethingASpecial”, b);</li><li>    a.doSomethingASpecial();</li><li>    return 0;</li><li>}</li><ol></ol></ol></td></tr></tbody></table><p><br/></p>

关于我们

法律声明

帮助中心

商务合作

相关文章

关于我们

法律声明

帮助中心

商务合作