1. 概要
本文描述一個通過C++可變引數模板實現C++反射機制的方法。該方法非常實用，在Nebula高效能網路框架中大量應用，實現了非常強大的動態載入動態建立功能。
C++11的新特性–可變模版引數（variadic templates）是C++11新增的最強大的特性之一，它對引數進行了高度泛化，它能表示0到任意個數、任意型別的引數。關於可變引數模板的原理和應用不是本文重點，不過通過本文中的例子也可充分了解可變引數模板是如何應用的。
熟悉Java或C#的同學應該都知道反射機制，很多有名的框架都用到了反射這種特性，簡單的理解就是隻根據類的名字（字串）建立類的例項。 C++並沒有直接從語言上提供反射機制給我們用，不過無所不能的C++可以通過一些trick來實現反射。Bwar也是在開發Nebula框架的時候需要用到反射機制，在網上參考了一些資料結合自己對C++11可變引數模板的理解實現了C++反射。
2. C++11之前的模擬反射機制實現
Nebula框架是一個高效能事件驅動通用網路框架，框架本身無任何業務邏輯實現，卻為快速實現業務提供了強大的功能、統一的介面。業務邏輯通過從Nebula的Actor類介面編譯成so動態庫，Nebula載入業務邏輯動態庫實現各種功能Server，開發人員只需專注於業務邏輯程式碼編寫，網路通訊、定時器、資料序列化反序列化、採用何種通訊協議等全部交由框架完成。
開發人員編寫的業務邏輯類從Nebula的基類派生，但各業務邏輯派生類對Nebula來說是完全未知的，Nebula需要載入這些動態庫並建立動態庫中的類例項就需要用到反射機制。第一版的Nebula及其前身Starship框架以C++03標準開發，未知類名、未知引數個數、未知引數型別、更未知實參的情況下，Bwar沒想到一個有效的載入動態庫並建立類例項的方式。為此，將所有業務邏輯入口類的建構函式都設計成無參建構函式。
Bwar在2015年未找到比較好的實現，自己想了一種較為取巧的載入動態庫並建立類例項的方法（這還不是反射機制，只是實現了可以或需要反射機制來實現的功能）。這個方法在Nebula的C++03版本中應用並實測通過，同時也是在一個穩定執行兩年多的IM底層框架Starship中應用。下面給出這種實現方法的程式碼：
CmdHello.hpp:
#ifdef __cplusplus
extern "C" {
#endif
// @brief 建立函式宣告
// @note 外掛程式碼編譯成so後存放到plugin目錄，框架載入動態庫後呼叫create()建立外掛類例項。
neb::Cmd* create();
#ifdef __cplusplus
}
#endif
namespace im
{
class CmdHello: public neb::Cmd
{
public:
CmdHello();
virtual ~CmdHello();
virtual bool AnyMessage();
};
} /* namespace im */CmdHello.cpp:
#include "CmdHello.hpp"
#ifdef __cplusplus
extern "C" {
#endif
neb::Cmd* create()
{
neb::Cmd* pCmd = new im::CmdHello();
return(pCmd);
}
#ifdef __cplusplus
}
#endif
namespace im
{
CmdHello::CmdHello()
{
}
CmdHello::~CmdHello()
{
}
bool CmdHello::AnyMessage()
{
std::cout << "CmdHello" << std::endl;
return(true);
}
}
實現的關鍵在於create()函式，雖然每個動態庫都寫了create()函式，但動態庫載入時每個create()函式的地址是不一樣的，通過不同地址呼叫到的函式也就是不一樣的，所以可以建立不同的例項。下面給出動態庫載入和呼叫create()函式，建立類例項的程式碼片段：
void* pHandle = NULL;
pHandle = dlopen(strSoPath.c_str(), RTLD_NOW);
char* dlsym_error = dlerror();
if (dlsym_error)
{
LOG4_FATAL("cannot load dynamic lib %s!" , dlsym_error);
if (pHandle != NULL)
{
dlclose(pHandle);
}
return(pSo);
}
CreateCmd* pCreateCmd = (CreateCmd*)dlsym(pHandle, strSymbol.c_str());
dlsym_error = dlerror();
if (dlsym_error)
{
LOG4_FATAL("dlsym error %s!" , dlsym_error);
dlclose(pHandle);
return(pSo);
}
Cmd* pCmd = pCreateCmd();對應這動態庫載入程式碼片段的配置檔案如下：
{"cmd":10001, "so_path":"plugins/CmdHello.so", "entrance_symbol":"create", "load":false, "version":1}這些程式碼實現達到了載入動態庫並建立框架未知類例項的目的。不過沒有反射機制那麼靈活，用起來也稍顯麻煩，開發人員寫好業務邏輯類之後還需要實現一個對應的全域性create()函式。
3. C++反射機制實現思考
Bwar曾經用C++模板封裝過一個基於pthread的通用執行緒類。下面是這個執行緒模板類具有代表性的一個函式實現，對設計C++反射機制實現有一定的啟發：
template <typename T>
void CThread<T>::StartRoutine(void* para)
{
T* pT;
pT = (T*) para;
pT->Run();
}與之相似，建立一個未知的類例項可以通過new T()的方式來實現，如果是帶引數的建構函式，則可以new T(T1, T2)來實現。那麼，通過類名建立類例項，建立”ClassName”與T的對應關係，或者建立”ClassName”與包含了new T()語句的函式的對應關係即可實現無參構造類的反射機制。考慮到new T(T1, T2)的引數個數和引數型別都未知，應用C++11的可變引數模板解決引數問題，即完成帶參構造類的反射機制。
4. Nebula網路框架中的C++反射機制實現
研究C++反射機制實現最重要是Nebula網路框架中有極其重要的應用，而Nebula框架在實現並應用了反射機制之後程式碼量精簡了10%左右，同時易用性也有了很大的提高，再考慮到應用反射機制後給基於Nebula的業務邏輯開發帶來的好處，可以說反射機制是Nebula框架僅次於以C++14標準重寫的重大提升。
Nebula的Actor為事件（訊息）處理者，所有業務邏輯均抽象成事件和事件處理，反射機制正是應用在Actor的動態建立上。Actor分為Cmd、Module、Step、Session四種不同型別。業務邏輯程式碼均通過從這四種不同型別時間處理者派生子類來實現，專注於業務邏輯實現，而無須關注業務邏輯之外的內容。Cmd和Module都是訊息處理入庫，業務開發人員定義了什麼樣的Cmd和Module對框架而言是未知的，因此這些Cmd和Module都配置在配置檔案裡，Nebula通過配置檔案中的Cmd和Module的名稱（字串）完成它們的例項建立。通過反射機制動態建立Actor的關鍵程式碼如下：
class Actor: public std::enable_shared_from_this<Actor>Actor建立工廠（注意看程式碼註釋）：
template<typename ...Targs>
class ActorFactory
{
public:
static ActorFactory* Instance()
{
if (nullptr == m_pActorFactory)
{
m_pActorFactory = new ActorFactory();
}
return(m_pActorFactory);
}
virtual ~ActorFactory(){};
// 將“例項建立方法（DynamicCreator的CreateObject方法）”註冊到ActorFactory，註冊的同時賦予這個方法一個名字“類名”，後續可以通過“類名”獲得該類的“例項建立方法”。這個例項建立方法實質上是個函式指標，在C++11裡std::function的可讀性比函式指標更好，所以用了std::function。
bool Regist(const std::string& strTypeName, std::function<Actor*(Targs&&... args)> pFunc);
// 傳入“類名”和引數建立類例項，方法內部通過“類名”從m_mapCreateFunction獲得了對應的“例項建立方法（DynamicCreator的CreateObject方法）”完成例項建立操作。
Actor* Create(const std::string& strTypeName, Targs&&... args);
private:
ActorFactory(){};
static ActorFactory<Targs...>* m_pActorFactory;
std::unordered_map<std::string, std::function<Actor*(Targs&&...)> > m_mapCreateFunction;
};
template<typename ...Targs>
ActorFactory<Targs...>* ActorFactory<Targs...>::m_pActorFactory = nullptr;
template<typename ...Targs>
bool ActorFactory<Targs...>::Regist(const std::string& strTypeName, std::function<Actor*(Targs&&... args)> pFunc)
{
if (nullptr == pFunc)
{
return (false);
}
bool bReg = m_mapCreateFunction.insert(
std::make_pair(strTypeName, pFunc)).second;
return (bReg);
}
template<typename ...Targs>
Actor* ActorFactory<Targs...>::Create(const std::string& strTypeName, Targs&&... args)
{
auto iter = m_mapCreateFunction.find(strTypeName);
if (iter == m_mapCreateFunction.end())
{
return (nullptr);
}
else
{
return (iter->second(std::forward<Targs>(args)...));
}
}動態建立類（注意看程式碼註釋）：
template<typename T, typename...Targs>
class DynamicCreator
{
public:
struct Register
{
Register()
{
char* szDemangleName = nullptr;
std::string strTypeName;
#ifdef __GNUC__
szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#else
// 注意：這裡不同編譯器typeid(T).name()返回的字串不一樣，需要針對編譯器寫對應的實現
//in this format?: szDemangleName = typeid(T).name();
szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#endif
if (nullptr != szDemangleName)
{
strTypeName = szDemangleName;
free(szDemangleName);
}
ActorFactory<Targs...>::Instance()->Regist(strTypeName, CreateObject);
}
inline void do_nothing()const { };
};
DynamicCreator()
{
m_oRegister.do_nothing(); // 這裡的函式呼叫雖無實際內容，卻是在呼叫動態建立函式前完成m_oRegister例項建立的關鍵
}
virtual ~DynamicCreator(){};
// 動態建立例項的方法，所有Actor例項均通過此方法建立。這是個模板方法，實際上每個Actor的派生類都對應了自己的CreateObject方法。
static T* CreateObject(Targs&&... args)
{
T* pT = nullptr;
try
{
pT = new T(std::forward<Targs>(args)...);
}
catch(std::bad_alloc& e)
{
return(nullptr);
}
return(pT);
}
private:
static Register m_oRegister;
};
template<typename T, typename ...Targs>
typename DynamicCreator<T, Targs...>::Register DynamicCreator<T, Targs...>::m_oRegister;上面ActorFactory和DynamicCreator就是C++反射機制的全部實現。要完成例項的動態建立還需要類定義必須滿足（模板）要求。下面看一個可以動態建立例項的CmdHello<a name=”CmdHello”></a>類定義（注意看程式碼註釋）：
// 類定義需要使用多重繼承。
// 第一重繼承neb::Cmd是CmdHello的實際基類（neb::Cmd為Actor的派生類，Actor是什麼在本節開始的描述中有說明）；
// 第二重繼承為通過類名動態建立例項的需要，與template<typename T, typename...Targs> class DynamicCreator定義對應著看就很容易明白第一個模板引數（CmdHello）為待動態建立的類名，其他引數為該類的建構函式引數。
// 如果引數為某個型別的引用，作為模板引數時應指定到型別。比如： 引數型別const std::string&只需在neb::DynamicCreator的模板引數裡填std::string
// 如果引數為某個型別的指標，作為模板引數時需指定為型別的指標。比如：引數型別const std::string*則需在neb::DynamicCreator的模板引數裡填std::string*
class CmdHello: public neb::Cmd, public neb::DynamicCreator<CmdHello, int32>
{
public:
CmdHello(int32 iCmd);
virtual ~CmdHello();
virtual bool Init();
virtual bool AnyMessage(
std::shared_ptr<neb::SocketChannel> pChannel,
const MsgHead& oMsgHead,
const MsgBody& oMsgBody);
};
再看看上面的反射機制是怎麼呼叫的：
template <typename ...Targs>
std::shared_ptr<Cmd> WorkerImpl::MakeSharedCmd(Actor* pCreator, const std::string& strCmdName, Targs... args)
{
LOG4_TRACE("%s(CmdName "%s")", __FUNCTION__, strCmdName.c_str());
Cmd* pCmd = dynamic_cast<Cmd*>(ActorFactory<Targs...>::Instance()->Create(strCmdName, std::forward<Targs>(args)...));
if (nullptr == pCmd)
{
LOG4_ERROR("failed to make shared cmd "%s"", strCmdName.c_str());
return(nullptr);
}
...
}MakeSharedCmd()方法的呼叫：
MakeSharedCmd(nullptr, oCmdConf["cmd"][i]("class"), iCmd);至此通過C++可變引數模板實現C++反射機制實現已全部講完，相信讀到這裡已經有了一定的理解，這是Nebula框架的核心功能之一，已有不少基於Nebula的應用實踐，是可用於生產的C++反射實現。
這個C++反射機制的應用容易出錯的地方是
- 類定義class CmdHello: public neb::Cmd, public neb::DynamicCreator<CmdHello, int32>中的模板引數一定要與建構函式中的引數型別嚴格匹配（不明白的請再閱讀一遍CmdHello類定義）。
- 呼叫建立方法的地方傳入的實參型別必須與形參型別嚴格匹配。不能有隱式的型別轉換，比如類建構函式的形參型別為unsigned int，呼叫ActorFactory<Targs…>::Instance()->Create()時傳入的實參為int或short或unsigned short或enum都會導致ActorFactory無法找到對應的“例項建立方法”，從而導致不能通過類名正常建立例項。
注意以上兩點，基本就不會有什麼問題了。
5. 一個可執行的例子
上面為了說明C++反射機制給出的程式碼全都來自Nebula框架。最後再提供一個可執行的例子加深理解。
DynamicCreate.cpp:
#include <string>
#include <iostream>
#include <typeinfo>
#include <memory>
#include <unordered_map>
#include <cxxabi.h>
namespace neb
{
class Actor
{
public:
Actor(){std::cout << "Actor construct" << std::endl;}
virtual ~Actor(){};
virtual void Say()
{
std::cout << "Actor" << std::endl;
}
};
template<typename ...Targs>
class ActorFactory
{
public:
//typedef Actor* (*ActorCreateFunction)();
//std::function< Actor*(Targs...args) > pp;
static ActorFactory* Instance()
{
std::cout << "static ActorFactory* Instance()" << std::endl;
if (nullptr == m_pActorFactory)
{
m_pActorFactory = new ActorFactory();
}
return(m_pActorFactory);
}
virtual ~ActorFactory(){};
//Lambda: static std::string ReadTypeName(const char * name)
//bool Regist(const std::string& strTypeName, ActorCreateFunction pFunc)
//bool Regist(const std::string& strTypeName, std::function<Actor*()> pFunc)
bool Regist(const std::string& strTypeName, std::function<Actor*(Targs&&... args)> pFunc)
{
std::cout << "bool ActorFactory::Regist(const std::string& strTypeName, std::function<Actor*(Targs... args)> pFunc)" << std::endl;
if (nullptr == pFunc)
{
return(false);
}
std::string strRealTypeName = strTypeName;
//[&strTypeName, &strRealTypeName]{int iPos = strTypeName.rfind(` `); strRealTypeName = std::move(strTypeName.substr(iPos+1, strTypeName.length() - (iPos + 1)));};
bool bReg = m_mapCreateFunction.insert(std::make_pair(strRealTypeName, pFunc)).second;
std::cout << "m_mapCreateFunction.size() =" << m_mapCreateFunction.size() << std::endl;
return(bReg);
}
Actor* Create(const std::string& strTypeName, Targs&&... args)
{
std::cout << "Actor* ActorFactory::Create(const std::string& strTypeName, Targs... args)" << std::endl;
auto iter = m_mapCreateFunction.find(strTypeName);
if (iter == m_mapCreateFunction.end())
{
return(nullptr);
}
else
{
//return(iter->second());
return(iter->second(std::forward<Targs>(args)...));
}
}
private:
ActorFactory(){std::cout << "ActorFactory construct" << std::endl;};
static ActorFactory<Targs...>* m_pActorFactory;
std::unordered_map<std::string, std::function<Actor*(Targs&&...)> > m_mapCreateFunction;
};
template<typename ...Targs>
ActorFactory<Targs...>* ActorFactory<Targs...>::m_pActorFactory = nullptr;
template<typename T, typename ...Targs>
class DynamicCreator
{
public:
struct Register
{
Register()
{
std::cout << "DynamicCreator.Register construct" << std::endl;
char* szDemangleName = nullptr;
std::string strTypeName;
#ifdef __GNUC__
szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#else
//in this format?: szDemangleName = typeid(T).name();
szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#endif
if (nullptr != szDemangleName)
{
strTypeName = szDemangleName;
free(szDemangleName);
}
ActorFactory<Targs...>::Instance()->Regist(strTypeName, CreateObject);
}
inline void do_nothing()const { };
};
DynamicCreator()
{
std::cout << "DynamicCreator construct" << std::endl;
m_oRegister.do_nothing();
}
virtual ~DynamicCreator(){m_oRegister.do_nothing();};
static T* CreateObject(Targs&&... args)
{
std::cout << "static Actor* DynamicCreator::CreateObject(Targs... args)" << std::endl;
return new T(std::forward<Targs>(args)...);
}
virtual void Say()
{
std::cout << "DynamicCreator say" << std::endl;
}
static Register m_oRegister;
};
template<typename T, typename ...Targs>
typename DynamicCreator<T, Targs...>::Register DynamicCreator<T, Targs...>::m_oRegister;
class Cmd: public Actor, public DynamicCreator<Cmd>
{
public:
Cmd(){std::cout << "Create Cmd " << std::endl;}
virtual void Say()
{
std::cout << "I am Cmd" << std::endl;
}
};
class Step: public Actor, DynamicCreator<Step, std::string, int>
{
public:
Step(const std::string& strType, int iSeq){std::cout << "Create Step " << strType << " with seq " << iSeq << std::endl;}
virtual void Say()
{
std::cout << "I am Step" << std::endl;
}
};
class Worker
{
public:
template<typename ...Targs>
Actor* CreateActor(const std::string& strTypeName, Targs&&... args)
{
Actor* p = ActorFactory<Targs...>::Instance()->Create(strTypeName, std::forward<Targs>(args)...);
return(p);
}
};
}
int main()
{
//Actor* p1 = ActorFactory<std::string, int>::Instance()->Create(std::string("Cmd"), std::string("neb::Cmd"), 1001);
//Actor* p3 = ActorFactory<>::Instance()->Create(std::string("Cmd"));
neb::Worker W;
neb::Actor* p1 = W.CreateActor(std::string("neb::Cmd"));
p1->Say();
//std::cout << abi::__cxa_demangle(typeid(Worker).name(), nullptr, nullptr, nullptr) << std::endl;
std::cout << "----------------------------------------------------------------------" << std::endl;
neb::Actor* p2 = W.CreateActor(std::string("neb::Step"), std::string("neb::Step"), 1002);
p2->Say();
return(0);
}Nebula框架是用C++14標準寫的，在Makefile中有預編譯選項，可以用C++11標準編譯，但未完全支援C++11全部標準的編譯器可能無法編譯成功。實測g++ 4.8.5不支援可變引數模板，建議採用gcc 5.0以後的編譯器，最好用gcc 6，Nebula用的是gcc6.4。
這裡給出的例子DynamicCreate.cpp可以這樣編譯：
g++ -std=c++11 DynamicCreate.cpp -o DynamicCreate程式執行結果如下：
DynamicCreator.Register construct
static ActorFactory* Instance()
ActorFactory construct
bool ActorFactory::Regist(const std::string& strTypeName, std::function<Actor*(Targs... args)> pFunc)
m_mapCreateFunction.size() =1
DynamicCreator.Register construct
static ActorFactory* Instance()
ActorFactory construct
bool ActorFactory::Regist(const std::string& strTypeName, std::function<Actor*(Targs... args)> pFunc)
m_mapCreateFunction.size() =1
static ActorFactory* Instance()
Actor* ActorFactory::Create(const std::string& strTypeName, Targs... args)
static Actor* DynamicCreator::CreateObject(Targs... args)
Actor construct
DynamicCreator construct
Create Cmd
I am Cmd
----------------------------------------------------------------------
static ActorFactory* Instance()
Actor* ActorFactory::Create(const std::string& strTypeName, Targs... args)
static Actor* DynamicCreator::CreateObject(Targs... args)
Actor construct
DynamicCreator construct
Create Step neb::Step with seq 1002
I am Step完畢，週末花了6個小時才寫完，找了個合適的時間釋出出來。
Nebula框架系列技術分享 之 《C++反射機制：可變引數模板實現C++反射》。 如果覺得這篇文章對你有用，如果覺得Nebula框架還可以，幫忙到Nebula的Github或碼雲給個star，謝謝。Nebula不僅是一個框架，還提供了一系列基於這個框架的應用，目標是打造一個高效能分散式服務叢集解決方案。
參考資料：