模块化编程思想及（C++）实践

原文地址：http://blog.163.com/lvan100@yeah/blog/static/68117214201482623154804/

作者相关的实践：https://github.com/lvan100/Modular

模块化思想

1.     将系统分成很多的模块，模块内部关注自身需要实现的核心业务。

2.     模块化的典型特点是：“模块间的低耦合”和“模块内的高聚合”。

模块的构成

1.     名称。全局范围内表明该模块独一无二的标识。

2.     依赖。称模块运行引用的其他模块为依赖。

3.     接口。将模块对外提供的服务称为接口。

模块的管理

1.     扫描模块列表

2.     分析模块依赖

3.     重排模块顺序

4.     初始化前准备

5.     模块的初始化

6.     模块反初始化

7.     模块最终销毁

模块化实践

#include <vector>

#include <string>

#include <functional>

using namespace std;

 

#ifndef _UNICODE

typedef std::string StdString;

#else

typedef std::wstring StdString;

#endif

定义模块结构

/**

 * 定义初始化及反初始化函数类型

 */

typedef function<void()> SelfFunction;

 

/**

 * 定义模块类型

 */

struct SelfModule

{

         /**

          * 模块的ID

          */

         StdString _id;

 

         /**

          * 模块的依赖，不同的依赖项之间用';'分割

          */

         StdString _depends;

 

         /**

          * 初始化之前的操作

          */

         SelfFunction _preinit;

 

         /**

          * 初始化函数

          */

         SelfFunction _init;

 

         /**

          * 反初始化函数

          */

         SelfFunction _uninit;

};

声明模块对象

/**

 * 声明模块的定义

 */

class DefModule

{

public:

         /*

          * 构造函数

          *

          * @Param id

          *        模块的ID

          * @Param depends

          *        模块的依赖

          * @Param preinit

          *        初始化之前的操作

          * @Param init

          *        模块的初始化函数

          * @Param uninit

          *        模块的反初始化函数

          * @Param destructor

          *        模块的析构函数

          */

         DefModule(StdString id

                   , StdString depends

                   , SelfFunction preinit

                   , SelfFunction init

                   , SelfFunction uninit

                   , SelfFunction destructor);

 

         /**

          * 析构函数

          */

         ~DefModule();

 

protected:

         /**

          * 析构函数

          */

         SelfFunction _destructor;

};

 

/**

 * DefModule

 */

DefModule::DefModule(StdString id

         , StdString depends

         , SelfFunction preinit

         , SelfFunction init

         , SelfFunction uninit

         , SelfFunction destructor)

         : _destructor(destructor)

{

         SelfModuleList* list = SelfModuleList::GetInstance();

 

         size_t offset = 0;

         size_t lastOffset = offset;

         while ((offset = depends.find(';', lastOffset)) != -1)

         {

                   StdString dep = depends.substr(lastOffset, offset - lastOffset);

                  

                   SelfModule& mod = list->FindModule(dep);

                   if (&mod == &SelfModuleList::_NullModule)

                   {

                            SelfModule module;

                            module._id = dep;

                            list->AddModule(module);

                   }

 

                   lastOffset = offset + 1;

         }

 

         SelfModule& mod = list->FindModule(id);

         if (&mod != &SelfModuleList::_NullModule)

         {

                   mod._init = init;

                   mod._uninit = uninit;

                   mod._preinit = preinit;

                   mod._depends = depends;

         }

         else

         {

                   SelfModule module;

                   module._id = id;

                   module._init = init;

                   module._uninit = uninit;

                   module._preinit = preinit;

                   module._depends = depends;

                   list->AddModule(module);               

         }

}

 

DefModule::~DefModule()

{

         _destructor();

}

定义模块列表

/**

 * 模块列表

 */

class SelfModuleList

{

public:

         /**

          * 获取唯一实例

          *

          * @Return 返回全局唯一的实例

          */

         static SelfModuleList* GetInstance()

         {

                   if (_instance != NULL)

                   {

                            return _instance;

                   }

 

                   if (_instance == NULL)

                   {

                            _instance = new SelfModuleList();

                   }

 

                   return _instance;

         }

 

         /**

          * 删除唯一实例

          */

         static void DelInstance()

         {

                   if (_instance != NULL)

                   {

                            delete _instance;

                            _instance = NULL;

                   }

         }

 

public:

         /**

          * 初始化之前的操作

          */

         void PreInits()

         {

                   for (auto iter = _list.begin(); iter != _list.end(); iter++)

                   {

                            (*iter)._preinit();

                   }

         }

 

         /**

          * 初始化函数

          */

         void Inits()

         {

                   for (auto iter = _list.begin(); iter != _list.end(); iter++)

                   {

                            (*iter)._init();

                   }

         }

 

         /**

          * 反初始化函数

          */

         void Uninits()

         {

                   for (auto iter = _list.rbegin(); iter != _list.rend(); iter++)

                   {

                            (*iter)._uninit();

                   }

         }

 

         /**

          * 增加模块

          *

          * @Param mod

          *        模块

          */

         void AddModule(SelfModule mod)

         {

                   _list.push_back(mod);

         }

 

         /**

          * 查找模块

          *

          * @Param id

          *        待查找的模块的ID

          * @Return 返回查找到的模块

          */

         SelfModule& FindModule(StdString id);

 

         /**

          * 模块的空引用

          */

         static SelfModule _NullModule;

 

protected:

         /**

          * 模块列表

          */

         vector<SelfModule> _list;

 

protected:

         SelfModuleList(void) {}

         ~SelfModuleList(void) {}

 

private:

         /**

          * 全局唯一的实例

          */

         static SelfModuleList* _instance;

};

 

/**

 * 模块的空引用

 */

SelfModule SelfModuleList::_NullModule;

 

/**

 * 全局唯一的实例

 */

SelfModuleList* SelfModuleList::_instance = NULL;

 

SelfModule& SelfModuleList::FindModule(StdString id)

{

         for (auto iter = _list.begin(); iter != _list.end(); iter++)

         {

                   if ((*iter)._id.compare(id) == 0)

                   {

                            return (*iter);

                   }

         }

         return _NullModule;

}

模块列表对象

/**

 * 定义当前模块

 */

static DefModule _Module(_T("SelfModuleList")

         , _T("")

         , [](){

         }

         , [](){

         }

         , [](){

         }

         , [](){

                   SelfModuleList::DelInstance();

         });