天天看點
傳回

C++反射機制：可變參數模闆實作C++反射

1. 概要

  本文描述一個通過C++可變參數模闆實作C++反射機制的方法。該方法非常實用，在Nebula高性能網絡架構中大量應用，實作了非常強大的動态加載動态建立功能。Nebula架構在Github的倉庫位址。

  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的關鍵代碼如下：

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類定義（注意看代碼注釋）：

// 類定義需要使用多重繼承。
// 第一重繼承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 <functional.h>
#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不僅是一個架構，還提供了一系列基于這個架構的應用，目标是打造一個高性能分布式服務叢集解決方案。

參考資料：

  • C++實作反射(根據類名動态建立對象)
  • 泛化之美--C++11可變模版參數的妙用
  • C++ 标準庫之typeid

作者：Bwar

出處：https://www.cnblogs.com/bwar/

Bwar傾力打造的高性能網絡架構Nebula：https://github.com/Bwar/Nebula

原創文章如轉載，請注明出處。

反射 反射機制 C++反射 C++反射實作 用C++實作反射
上一篇: 通過UNIX域套接字傳遞描述符的應用
下一篇: Protobuf協定應用幹貨

繼續閱讀