零零客微文大全00ke.net

  • 分享一种不太完美的接入网关设计
  • 来源：腾讯大讲堂


作者：朱江，腾讯工程师。

写在前面：
如上图所示，客户端通过HTTP+JSON协议请求ProxyServer，由其派发到后端不同服务的不同接口处理，从而获取结果。那么ProxyServer需要具备怎样的特性呢？
1.修改协议、新增接口及服务时，ProxyServer可以做到不修改代码，不重启，只需要增加新服务的配置即可；

2.ProxyServer支持TAF+JCE调用，后端服务只需要专注业务，提供各自的TAF接口即可，这样有个好处是，不管什么语言(C++,node.js,python)平台开发的服务，只要支持TAF协议就可以接入ProxyServer，而不用做任何修改；
本文探讨的方案，基本满足上面两点，但是有个缺点是：当修改新增协议时，ProxyServer需要重新编译JCE发布服务。
限制
基于C++ 98和taf框架实现。众所周知，C++98并没有像JAVA那样的反射机制，也不想引入第三方反射库（RTTR，cpgf...）。
思路
由于C++ 98没有反射机制，那么如何根据客户端传过来的命令字创建对象呢，如果是硬编码在代码里，那么可以这样写：
switch (cmd)
{
    case HEAD: new head;
    case REQ: new req;
}
很容易我们可以看出一个致命缺点，那就是新增或修改协议，代码也需要作相应的修改，这样费时费力，也容易出错。
如何解决这个问题呢，可以利用C++静态类对象自动创建，从而自动执行构造函数的特性，把相关的类型信息注册到map结构里，这样就可以通过命令字得到对应的类对象，就像类工厂一样。
但是这样还不够，因为当新增加一个协议结构体时，需要在ProxyServer代码里增加对应的类型注册代码，如：REGISTER_CLASS(THComm, JceStructBase, _Notification, AddNotiReq)。解决办法是利用JCE2CPP工具，当转换JCE文件为C++代码时，把相应的注册代码也添加到JCE产生的CPP文件中。
通过命令字字符串得到类对象，就可以把请求消息里的JSON数据序列化为JCE对象结构，从而完成参数的JCE序列化，实现TAF接口+JCE调用。
类对象注册及参数注册
我们先来看一个客户端请求消息的例子，如下：
{
    "args": {
        "req": {
            "hospitalId": "10056"
        },
        "head": {
            "requestId": "ooJQ346G2CMqcSujAt8yE8-Stutc",
            "openId": "ooJQ346G2CMqcSujAt8yE8-Stutc"
        }
    },
    "service": "TencentHealthRegister",
    "func": "getHospitalInfo",
    "context": {
        "requestId": "b9bf3541-3753-11e9-8213-e5de4f5e7b53",
        "traceId": "b9bf3540-3753-11e9-8213-e5de4f5e7b53"
    }
}
对应的JCE接口定义，如下：
module TencentHealthMini {
 struct ThHead{
 0 optional string requestId;
 1 require string openId;
 2 optional string channel;
 3 optional string cityCode;
 };
 struct HospitalReq{
 0 require string hospitalId;
 1 optional string platformId;
 };
 struct HospitalRsp{
 0 require Result result;
 1 require HospitalInfo hospitalInfo;
 };
interface ThRegisterMain {
    int getHospitalInfo(ThHead head,HospitalReq req, out HospitalRsp rsp);
}
}
我们可以看到，请求消息里，客户端会在请求消息里告诉ProxyServer，请求的服务是"service": "TencentHealthRegister"，调用的接口是"func": "getHospitalInfo"，而接口参数通过”req”和”head”的json串和JCE接口定义的req和head结构对应。这里就有一个问题需要我们解决，如何知道req对应的类型呢？
一种方法是通过配置，在我们的服务配置文件上写明某服务某接口的req对应类型是HospitalReq，如下所示，这样做的缺点是协议改动，配置也需要跟着改动。

        
            head = ThHead
            req = HospitalReq

rsp = HospitalRsp
</getHospitalInfo>
较好的办法是：可以像类对象注册一样，把参数类型也注册到map，同时TAF接口参数JCE序列化是需要按顺序的，所以参数顺序也是需要我们知道的。
1.类对象注册实现
定义一个静态map* >用于存储命令字、对象的产生类。
template<typename Base>
class ObjGen
{
public:
    virtual Base* operator()()
    {
        return NULL;
    }
};

template<typename Base>
std::map<std::string, ObjGen* >& GetObjMap()
{
    static std::map<std::string, ObjGen* > obj_map;
    return obj_map;
}
ObjGen是一个模板基类，被具体的子类所继承，从而可以new出对应的类对象。而各个参数的静态类对象自动创建时，会把对应的产生类对象插入到obj_map。
#define REGISTER_CLASS(BASE_NAMESPACE, BASE_NAME, CLASS_NAMESPACE, CLASS_NAME)\
class Gen##CLASS_NAMESPACE##CLASS_NAME: public GenObjectFun\
{\
    public:\
           BASE_NAMESPACE::BASE_NAME* operator()()\
  {\
      return new CLASS_NAMESPACE::CLASS_NAME;\
  }\
};\
\
static struct CLASS_NAMESPACE##CLASS_NAME##AutoInit\
{\
    CLASS_NAMESPACE##CLASS_NAME##AutoInit()\
    {\
        if(GetObjMap().find(#CLASS_NAMESPACE"."#CLASS_NAME) == GetObjMap().end())\
            GetObjMap().insert(std::make_pair(#CLASS_NAMESPACE"."#CLASS_NAME, new Gen##CLASS_NAMESPACE##CLASS_NAME));\
    }\
}__##CLASS_NAMESPACE##CLASS_NAME##AutoInit;
通过GetObject，传进类型名字符串就可以得到对应类对象
template <typename Base>
Base* GetObject(const std::string& class_name){
    typename std::map<std::string, ObjGen* >::const_iterator iter = GetObjMap().find(class_name);
    if(iter == GetObjMap().end())
    {
        return NULL;
    }
    return (*iter->second)();
}


来到这里，恭喜你已经可以得到对应的类对象了，但是明显还不够，因为没有类型信息，没办法调用对象的接口，幸好所有的JCE对象都是继承taf::JceStructBase，我们可以利用多态，用基类指针调用虚函数方法来完成json到jce的序列化和序列化(readFromJsonStringV2/writeToJsonStringV2)。
struct HospitalReq : public taf::JceStructBase
{
    public:
        static string className()
        {
            return "TencentHealthMini.HospitalReq";
        }
        static string MD5()
        {
            return "325d87d477a8cf7a6468ed6bb39da964";
        }
    ......
}
但是我们发现taf::JceStructBase并没有定义所需要的虚函数，不想修改TAF框架代码，需要怎么样解决这个问题呢？
namespace taf
{
//////////////////////////////////////////////////////////////////
    struct JceStructBase
    {
    protected:
        JceStructBase() {}

        ~JceStructBase() {}
    };
    struct JceException : public std::runtime_error
    {
        JceException(const std::string& s) : std::runtime_error(s) {}
    };
    struct JceEncodeException : public JceException
    {
        JceEncodeException(const std::string& s) : JceException(s) {}
    };
    struct JceDecodeException : public JceException
    {
        JceDecodeException(const std::string& s) : JceException(s) {}
    };
    ......
}
可以实现自己的基类，声明需要的虚函数方法，并让所有JCE类继承我们的基类，这样基类对象就可以调用子类的虚函数了。
namespace THComm
{
//////////////////////////////////////////////////////////////////
    struct JceStructBase:public taf::JceStructBase
    {
        public:
            JceStructBase() {}
            virtual ~JceStructBase() {}
            virtual void writeTo(taf::JceOutputStream& _os, UInt8 tag) const 
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual void writeToJson(rapidjson::Value& _jVal, rapidjson::Document::AllocatorType& _jAlloc) const
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual std::string writeToJsonString() 
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual std::string writeToJsonStringV2() const
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual void readFrom(taf::JceInputStream& _is, UInt8 tag)
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual void readFromJson(const rapidjson::Value& _jVal, bool isRequire = true)
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual void readFromJsonString(const std::string & str)
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual void readFromJsonStringV2(const std::string & str)
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual void writeToString(std::string &content;) 
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual void readFromString(const std::string & str)
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual ostream& display(ostream& _os, int _level=0) const
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
            virtual ostream& displaySimple(ostream& _os, int _level=0) const
            {
                LOG_ERROR("not supported");
                throw new std::runtime_error("not supported.");
            }
    };
}
修改JCE2CPP工具，让每个类继承我们的基类，从而调用子类的虚函数。
struct HospitalReq : public THComm::JceStructBase
{
    public:
        static string className()
        {
            return "TencentHealthMini.HospitalReq";
        }
        static string MD5()
        {
            return "325d87d477a8cf7a6468ed6bb39da964";
        }
    ......
}
修改JCE2CPP工具，在产生的对应CPP文件加上各个接口参数对象的注册代码。
#include "ThRegisterMain.h"
#include "jce/wup.h"
#include "servant/BaseF.h"
using namespace wup;
namespace TencentHealthMini
{
    REGISTER_CLASS(THComm, JceStructBase, TencentHealthMini, HospitalReq)
    REGISTER_CLASS(THComm, JceStructBase, TencentHealthMini, HospitalRsp)
    REGISTER_CLASS(THComm, JceStructBase, TencentHealthMini, PayAppointReq)
    REGISTER_CLASS(THComm, JceStructBase, TencentHealthMini, PayAppointRsp)
    REGISTER_CLASS(THComm, JceStructBase, TencentHealthMini, ScheduleReq)
    REGISTER_CLASS(THComm, JceStructBase, TencentHealthMini, ScheduleRsp)
    REGISTER_CLASS(THComm, JceStructBase, TencentHealthMini, SourceReq)
......
}
2.参数类型注册实现
同样，声明一个static map用于存储参数类型，不管入参还是出参都存于此。
Key:命名空间+接口类+接口名+参数名
Value:参数类型，比如JCE接口定义：int getHospitalInfo(ThHead head,HospitalReq req,out HospitalRsp rsp);head变量对应的类型是ThHead，req变量对应的类型是HospitalReq，rsp变量对应的类型是HospitalRsp。
map<string, string>& GetParameterTypeMap()
{
    static map<string, string> parameter_type_map;
    return parameter_type_map;
}
注册代码，和上面同样原理，可以看到，除了插入到参数类型map，我们还根据OUT将参数分别插入到入参和出参的vector，用来存储JCE接口的入参和出参顺序，在调用taf接口序列化参数需要用到。
#define REGISTER_PARAMETER(CLASS_NAMESPACE, INTERFACE_CLASS, FUNC, PARAMETER, PARAMETER_TYPE, OUT)\
static struct CLASS_NAMESPACE##INTERFACE_CLASS##FUNC##PARAMETER##Initializer\
{\
    CLASS_NAMESPACE##INTERFACE_CLASS##FUNC##PARAMETER##Initializer()\
    {\
        if (GetParameterTypeMap().find(PARAMETER_INDEX(CLASS_NAMESPACE, INTERFACE_CLASS, FUNC, PARAMETER)) == GetParameterTypeMap().end())\
            GetParameterTypeMap().insert(make_pair(PARAMETER_INDEX(CLASS_NAMESPACE, INTERFACE_CLASS, FUNC, PARAMETER), #PARAMETER_TYPE));\
        \
        if (!OUT)\
        {\
            map >::iterator iter = GetParameterSequenceMap().find(FUNC_INDEX(CLASS_NAMESPACE, INTERFACE_CLASS, FUNC));\
            if (iter == GetParameterSequenceMap().end())\
            {\
                vector parameterSequence;\
                parameterSequence.push_back(#PARAMETER);\
                GetParameterSequenceMap().insert(make_pair(FUNC_INDEX(CLASS_NAMESPACE, INTERFACE_CLASS, FUNC), parameterSequence));\
            }\
            else\
            {\
                vector& parameterSequence = iter->second;\
                parameterSequence.push_back(#PARAMETER);\
            }\
        }\
        else \
        {\
            map >::iterator iter = GetOutParameterSequenceMap().find(FUNC_INDEX(CLASS_NAMESPACE, INTERFACE_CLASS, FUNC));\
            if (iter == GetOutParameterSequenceMap().end())\
            {\
                vector outParameterSequence;\
                outParameterSequence.push_back(#PARAMETER);\
                GetOutParameterSequenceMap().insert(make_pair(FUNC_INDEX(CLASS_NAMESPACE, INTERFACE_CLASS, FUNC), outParameterSequence));\
            }\
            else\
            {\
                vector& outParameterSequence = iter->second;\
                outParameterSequence.push_back(#PARAMETER);\
            }\
        }\
    }\
}__##CLASS_NAMESPACE##INTERFACE_CLASS##FUNC##PARAMETER##Initializer;
对外提供获取参数类型、接口入参顺序、出参顺序的三个接口
//获取参数类型
void PrintParameterTypeMap();
map& GetParameterTypeMap();
string GetParameterType(const string& CLASS_NAMESPACE, const string& INTERFACE_CLASS, const string& FUNC, const string& PARAMETER);

//获取入参顺序
void PrintParameterSequence();
map<string, vector<std::string> >& GetParameterSequenceMap();
vector<string> GetParameterSequence(const string& CLASS_NAMESPACE, const string& INTERFACE_CLASS, const string& FUNC);

//出参顺序
void PrintOutParameterSequence();
map<string, vector<string> >& GetOutParameterSequenceMap();
vector<string> GetOutParameterSequence(const string& CLASS_NAMESPACE, const string& INTERFACE_CLASS, const string& FUNC);

map<string, vector<string> >& GetParameterSequenceMap()
{
    static map<string, vector<string> > parameter_sequence_map;
    return parameter_sequence_map;
}

map<string, vector<string> >& GetOutParameterSequenceMap()
{
    static map<string, vector<string> > out_parameter_sequence_map;
    return out_parameter_sequence_map;
}
修改JCE2CPP代码，添加注册代码。
#include "ThRegisterMain.h"
#include "jce/wup.h"
#include "servant/BaseF.h"
using namespace wup;
namespace TencentHealthMini
{
    REGISTER_CLASS(THComm, JceStructBase, TencentHealthMini, HospitalReq)
    REGISTER_CLASS(THComm, JceStructBase, TencentHealthMini, HospitalRsp)
    ......

    REGISTER_PARAMETER(TencentHealthMini, ThRegisterMain, getHospitalInfo, head, TencentHealthMini::ThHead, 0)
    REGISTER_PARAMETER(TencentHealthMini, ThRegisterMain, getHospitalInfo, req, TencentHealthMini::HospitalReq, 0)
    REGISTER_PARAMETER(TencentHealthMini, ThRegisterMain, getHospitalInfo, rsp, TencentHealthMini::HospitalRsp, 1)
    ......
}


后端服务taf接口调用
1.按JCE接口入参顺序，将所有入参JCE序列化填充taf::JceOutputStream对象
bool httpImp::tafAsyncCall(HttpRequestPtr httpReq)
{
    RequestInfo& reqInfo = httpReq->reqInfo;
    taf::JceOutputStream os;

    for (size_t i = 0; i < reqInfo.argsSequence.size(); i++)
    {
        string& argName = reqInfo.argsSequence[i];
        Arg& arg = reqInfo.args[argName];
        if (NULL == arg._pJceStr)
        {
            LOG_ERROR(httpReq->requestId << ",argName:" << argName << ",jce struct is null");
            return false;
        }

        arg._pJceStr->readFromJsonStringV2(arg.data);
        arg._pJceStr->writeTo(os, i+1);
    }
    ......
}
2.调用taf框架提供的异步回调RPC接口，填入调用服务接口名，参数序列化数据，回调类对象(见下面)。
    ...... 
    CommCallbackPtr callback = new CommCallback;
    callback->httpReq = httpReq;
    map::iterator iter = g_app._proxyMap.find(reqInfo.service);
    LOG_DEBUG(httpReq->requestId << ",THProxyServer costime:" << TNOWMS - httpReq->acceptReqTime);
    
    if (iter != g_app._proxyMap.end())
    {
        LOG_DEBUG(httpReq->requestId
            << ",service:" << reqInfo.service
            << ",func:" << reqInfo.func
            << "," << reqInfo.reqStr
            << ",context:" << contextStr);
        taf::ServantPrx proxy = iter->second;
        proxy->taf_invoke_async(taf::JCENORMAL, reqInfo.func, os.getByteBuffer(), context, mStatus, callback);
    }
    else
    {
        LOG_ERROR(httpReq->requestId << ",service:" << reqInfo.service << ",");
        return false;
    }


处理接口响应
我们需要实现一个通用的回调类，在onDispatch回调处理后端服务的返回数据(JCE结构)。
class CommCallback: public taf::ServantProxyCallback
{
public:
    virtual ~CommCallback(){}

    void done()
    {

    }

    void exception(taf::Int32 ret)
    {
        LOG_ERROR("ret:" << ret);
    }

    int procResponse(taf::ReqMessagePtr msg ,taf::JceInputStream& is, int ret);
    
    virtual int onDispatch(taf::ReqMessagePtr msg);

    HttpRequestPtr httpReq;
};
typedef TC_AutoPtr CommCallbackPtr;
Taf接口响应报文结构：tag0表示接口返回值，后面按入参数顺序填充tag1,tag2...tagN，出参同样按接口定义顺序紧跟其后tagN+1,tagN+2...
如下所示，我们就可以得到所有出参的json串，从而可以给客户端回消息。



一种分布式布隆过滤器设计


那些熟悉却说不出的设计法则


微信大更新！支持多任务操作，还有超好用的 10 大新功能


年度好文：腾讯工程师的自我修炼






















    已同步到看一看
















    发送中













    其他

    << 41 42 43 44 45 >> 

    公众号 • 腾讯大讲堂

    热门文章

    近期更新

    Flag Counter
    • 简　　介：零零客微信公众平台收录了微信公众号,微信明星号,微信搞笑号等各种类型的微信公众号以及头条号。
    • 本站声明：本站与腾讯微信、微信公众平台、头条等无任何关联，非腾讯微信官方网站。
    • 版权声明：本站收录微信公众号和微信文章内容全部来自于网络，仅供个人学习、研究或者欣赏使用。版权归原作者所有。禁止一切商业用途。其中内容并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。如果您发现零零客网站上有侵犯您的知识产权的内容，请与我们联系，我们会及时修改或删除。 [文章删除]