北冰洋以北 发表于 2025-2-20 22:14:38

[实现Rpc] 消息抽象层的具体实现

目次
具象层 _ 消息抽象的实现
信息的抽象类
实现
JsonMessage
JsonRequest & JsonResponse
消息-差别消息分装实现
实现
Request
RpcRequest
TopicRequest
ServiceRequest
Response
RpcResponse
TopicResponse
ServiceResponse
实现 生产工厂
本篇文章继 BaseMessage 后继续实现，具象层架构图
https://i-blog.csdnimg.cn/direct/0eb51c2be477476e829ffa95ab8570d1.png
具象层 _ 消息抽象的实现

信息的抽象类


[*]JsonMessage


[*]

[*]Json的信息内容。
[*]由JsonRequest和JsonResponse继承来实现差别的功能。

实现

JsonMessage


https://i-blog.csdnimg.cn/img_convert/ec8689414870c6243676696146e2fa1a.png
typedef std::pair<std::string,int> Address;
    class JsonMessage:public BaseMessage{
      //继承
      public:
      using ptr=std::shared_ptr<JsonMessage>;
      virtual std::string serialize() override{
            //！！！！override 继承重写的强校验
            std::string body;
            bool ret=JSON::serialize(_body,body);
            if(ret==false){
                return std::string();
                //序列化失败
            }
            return body;
      }
      virtual bool unserialize(const std::string &msg) override{
            return JSON::unserialize(msg,_body);
      }

      protected:
            Json::Value _body;
    } ⭕ 前文回顾
   1.over ride 继承重写的强校验
[多态] 两个条件 | 虚函数表 | 抽象类 | override 和 final | 重载 重写 重定义

   2.
继承类不能用 private，要用 protected
JsonRequest & JsonResponse


https://i-blog.csdnimg.cn/img_convert/862c18bb8a6bf7a67a23b7099eec3348.png
//2.
   class JsonRequest:public JsonMessage{
      public:
            using ptr=std::shared_ptr<JsonRequest>;
   };

   class JsonResponse:public JsonMessage{
      public:
            using ptr=std::shared_ptr<JsonResponse>;
            virtual bool check() override{
                //在响应中，大部分的响应都 只有响应状态码
                //only chaeck 状态码是否存在，类型 是否正确
                if(_body.isNull()==true){
                  ELOG("响应中 没有响应状态码！");
                  return false;
                }
                if(_body.isIntegral()==false){
                  ELOG("响应状态码 类型错误！");
                  return false;
                }
                return true;
            }

            virtual RCode rcode(){
                return (RCode)_body.asInt();
                //将body中的提示码 整型化
            }
            virtual void setRCode(RCode rcode){
                _body=(int)rcode;
            }
   };   1.通过继承 提高代码复用，去冗余

   2. 使用 vi 查询 json 中接口
vi /usr/include/jsoncpp/json/value.h
esc 下/查询

https://i-blog.csdnimg.cn/img_convert/ec4a46e04d3474febb1d28df17960a80.png
可以看到上述检测接口
消息-差别消息分装实现


[*]JsonRequest


[*]

[*]Json的请求信息。
[*]JsonRequest实现的派生类：


[*]
[*]RpcRequest：用于远程过程调用请求的实现。
[*]TopicRequest：可能与特定主题或话题相关的请求实现。
[*]ServiceRequest：针对服务请求的具体实现。


[*]JsonResponse


[*]

[*]Json的回复信息。
[*]JsonResponse实现的派生类：


[*]
[*]RpcResponse：对应于远程过程调用响应的实现。
[*]TopicResponse：与特定主题或话题相关响应的实现。
[*]ServiceResponse：服务于具体服务响应的实现。

实现

Request


https://i-blog.csdnimg.cn/img_convert/e09c3831bf1f0c97fa775fc33ae17b4b.png
RpcRequest

class RpcRequest:public JsonRequest{
    public:
      using ptr=std::shared_ptr<RpcRequest>;
      virtual bool check() override{
            //重写 check 函数
            //rpc 请求中，包含 请求方法名称-字符串，参数字段-对象
            if(_body.isNull()==true||
            _body.isString()==false){
                ELOG("RPC请求中 没有方法名称 或者 方法名称 类型错误");
                return false;
            }

            if(_body.isNull()==true||
            _body.isObject()==false
            ){
                ELOG("RPC请求中 没有 参数信息或 参数信息类型错误！");
                return false;
            }
            return true;
      }
      std::string method(){
            return _body.asString();
      }
      void setMethod(const std::string &method_name){
            _body=method_name;
      }

      Json::Value params(){
            return _body;
      }
      void setParams(const Json::Value &params){
            _body=params;
      }
}; TopicRequest

    class TopicRequest : public JsonRequest {
      public:
            using ptr = std::shared_ptr<TopicRequest>;
            virtual bool check() override {
                //rpc请求中，包含请求方法名称-字符串，参数字段-对象
                if (_body.isNull() == true ||
                  _body.isString() == false) {
                  ELOG("主题请求中没有主题名称或主题名称类型错误！");
                  return false;
                }
                if (_body.isNull() == true ||
                  _body.isIntegral() == false) {
                  ELOG("主题请求中没有操作类型或操作类型的类型错误！");
                  return false;
                }
                if (_body.asInt() == (int)TopicOptype::TOPIC_PUBLISH &&
                  (_body.isNull() == true ||
                  _body.isString() == false)) {
                  ELOG("主题消息发布请求中没有消息内容字段或消息内容类型错误！");
                  return false;
                }
                return true;
            }
            
            std::string topicKey() {
                return _body.asString();
            }
            void setTopicKey(const std::string &key) {
                _body = key;
            }
            TopicOptype optype() {
                return (TopicOptype)_body.asInt();
            }
            void setOptype(TopicOptype optype) {
                _body = (int)optype;
            }
            std::string topicMsg() {
                return _body.asString();
            }
            void setTopicMsg(const std::string &msg) {
                _body = msg;
            }

    }; ServiceRequest

class ServiceRequest : public JsonRequest {
      public:
            using ptr = std::shared_ptr<ServiceRequest>;
            virtual bool check() override {
                //rpc请求中，包含请求方法名称-字符串，参数字段-对象
                if (_body.isNull() == true ||
                  _body.isString() == false) {
                  ELOG("RPC请求中没有方法名称或方法名称类型错误！");
                  return false;
                }
                if (_body.isNull() == true ||
                  _body.isIntegral() == false) {
                  ELOG("服务请求中没有操作类型或操作类型的类型错误！");
                  return false;
                }

      //!!!!!!!!!! 服务发现不需要提供主机 ip port
                if (_body.asInt() != (int)(ServiceOptype::SERVICE_DISCOVERY) &&
                  (_body.isNull() == true ||
                  _body.isObject() == false ||
                  _body.isNull() == true ||
                  _body.isString() == false ||
                  _body.isNull() == true ||
                  _body.isIntegral() == false)) {
                  ELOG("服务请求中主机地址信息错误！");
                  return false;
                }
                return true;
            }


            std::string method() {
                return _body.asString();
            }

            //引用传参
            void setMethod(const std::string &method_name) {
                _body = method_name;
            }

            ServiceOptype optype(){
                return (ServiceOptype)_body.asInt();
            }
//枚举类型较小 前面不加&也行
            void setOptype(ServiceOptype optype){
                _body=(int)optype;
            }

            Address host(){
                Address addr;
    //!!!!!!!!!!!!!!!
    //粗心写成 _body 报错 排查了快半小时qwq      
                addr.first=_body.asString();
                addr.second=_body.asInt();
                return addr;
            }

            void setHost(const Address &host){
                Json::Value val;
                val=host.first;
                val=host.second;
                _body=val;
            }
    }; 1.询问中的服务发现

https://i-blog.csdnimg.cn/img_convert/f6cd1c09ec8b2aff5572591425c157c7.png

2.

https://i-blog.csdnimg.cn/img_convert/95b83b2a97365bf679f014824ee5d702.png

3.

https://i-blog.csdnimg.cn/img_convert/b08a023c9da3b7d69d4a4c708d3d8ab7.png


   ⭕为什么 要 这样设计？

https://i-blog.csdnimg.cn/img_convert/6188fb21e28bb46ce6c8ff58dceed238.png
issues 回复：
这是向外提供的两个不i同功能的接口呀


[*]一个是用于获取body中的数据的
[*]一个是用户设置body内容的....
Response


https://i-blog.csdnimg.cn/img_convert/4e637f4680e37b5c9f834ee1ec14e4e5.png
RpcResponse

class RpcResponse:public JsonResponse{
    public:
      using ptr=std::shared_ptr<RpcResponse>;
      virtual bool check() override{
            if(_body.isNull()==true||
               _body.isIntegral()==false )
            {
                ELOG("响应中没有 响应状态码，或者 状态码 类型错误");
                return false;
            }

         if (_body.isNull() == true) {
                  ELOG("响应中没有Rpc调用结果,或结果类型错误！");
                  return false;
                }
                return true;
            }
            Json::Value result() {
                return _body;
            }
            void setResult(const Json::Value &result) {
                _body = result;
            }
    };
TopicResponse

class TopicResponse : public JsonResponse {
      public:
            using ptr = std::shared_ptr<TopicResponse>;
    }; ServiceResponse


https://i-blog.csdnimg.cn/img_convert/3f1e4078796a373c9880d7b3556153bd.png
class ServiceResponse : public JsonResponse {
      public:
            using ptr = std::shared_ptr<ServiceResponse>;
            virtual bool check() override {
                if (_body.isNull() == true ||
                  _body.isIntegral() == false) {
                  ELOG("响应中没有响应状态码,或状态码类型错误！");
                  return false;
                }
                if (_body.isNull() == true ||
                  _body.isIntegral() == false) {
                  ELOG("响应中没有操作类型,或操作类型的类型错误！");
                  return false;
                }

//！！！！！！！！！！！！！！！对服务发现部分 进行处理
                if (_body.asInt() == (int)(ServiceOptype::SERVICE_DISCOVERY) &&
                   (_body.isNull() == true ||
                  _body.isString() == false ||
                  _body.isNull() == true ||
                  _body.isArray() == false)) {
                  ELOG("服务发现响应中响应信息字段错误！");
                  return false;
                }
                return true;
            }
            ServiceOptype optype() {
                return (ServiceOptype)_body.asInt();
            }
            void setOptype(ServiceOptype optype) {
                _body = (int)optype;
            }


            std::string method() {
                return _body.asString();
            }
            void setMethod(const std::string &method) {
                _body = method;
            }

// !!!!!!!!!!!!!!!!!!!!!!!!!
            void setHost(std::vector<Address> addrs) {
                for (auto &addr : addrs) {
                  Json::Value val;
                  val = addr.first;
                  val = addr.second;
                  _body.append(val);
                }
            }
            std::vector<Address> hosts() {
                std::vector<Address> addrs;
                int sz = _body.size();
                for (int i = 0; i < sz; i++) {
                  Address addr;
                  addr.first = _body.asString();
                  addr.second = _body.asInt();
                  addrs.push_back(addr);
                }
                return addrs;
            }
    }; ⭕

https://i-blog.csdnimg.cn/img_convert/480f0001417466bcff621fe37893a416.png
实现 生产工厂

//实现一个消息对象的生产工厂
    class MessageFactory {
      public:
            static BaseMessage::ptr create(MType mtype) {
                switch(mtype) {
                  case MType::REQ_RPC : return std::make_shared<RpcRequest>();
                  case MType::RSP_RPC : return std::make_shared<RpcResponse>();
                  case MType::REQ_TOPIC : return std::make_shared<TopicRequest>();
                  case MType::RSP_TOPIC : return std::make_shared<TopicResponse>();
                  case MType::REQ_SERVICE : return std::make_shared<ServiceRequest>();
                  case MType::RSP_SERVICE : return std::make_shared<ServiceResponse>();
                }
                return BaseMessage::ptr();
            }
            
            template<typename T, typename ...Args>
            static std::shared_ptr<T> create(Args&& ...args) {
                return std::make_shared<T>(std::forward(args)...);
            }
    }; 下一篇 将遵循 边写边测试，对上面 具象层的 消息类型代码的测试 进行整理

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页: [1]
查看完整版本: [实现Rpc] 消息抽象层的具体实现