RpcChannel的调用过程

某个节点发布了rpc服务和方法，那么其他节点想要调用，首先要按照服务发布方的格式要求。
比如在该示例中服务名称为UserServiceRpc，提供了Login和Register方法，

那么在生成proto文件后，会有两个类，UserServiceRpc使用在rpc服务发布端

UserServiceRpc_Stub 用于服务请求端

#include <iostream>
#include "mprpcApplication.h"
#include "user.pb.h"

int main(int argc, char** argv)
{
    // 整个程序启动后，想使用mprpc框架来享受rpc服务调用，一定要先调用框架的初始化函数（只初始化一次）
    MprpcApplication::Init(argc, argv);

    // 演示调用远程发布的rpc方法Login
    fixbug::UserServiceRpc_Stub stub(new MprpcChannel());

    // rpc方法的请求参数
    fixbug::LoginRequest request;
    request.set_name("zhang san");
    request.set_pwd("123456");
    // rpc方法的响应
    fixbug::LoginResponse response;

    // 发起rpc方法的调用 同步的rpc调用过程
    stub.Login(nullptr, &request, &response, nullptr);   // RpcChannel->RpcChannel::callMethod 集中来做所有rpc方法调用的参数序列化和网络发送
    
	// 一次rpc调用过程，度调用结果
    if (0 == response.result().errcode())
    {
        std::cout << "rpc login response success: " << response.success() << std::endl;
    }
    else
    {
        std::cout << "rpc login response error: " << response.result().errmsg() << std::endl;
    }
    
    return 0;
}

RpcChannel在这里不要理解成管道的意思，这里相当于中继作用，

#pragma once

#include <google/protobuf/service.h>

class MprpcChannel : public google::protobuf::RpcChannel
{
public:
    MprpcChannel(){}
    // 所有通过stub代理对象调用的rpc方法，都走到这里了，统一做rpc方法调用的的数据序列化和网络发送
    void CallMethod(const google::protobuf::MethodDescriptor* method,
                            google::protobuf::RpcController* controller, const google::protobuf::Message* request,
                            google::protobuf::Message* response, google::protobuf::Closure* done);
};

CallMethod实现

#include "mprpcApplication.h"

#include <string>
#include "rpcHeader.pb.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>
#include <error.h>
/*
header_size + service_name method_name args_size + args
*/
// 所有通过stub代理对象调用的rpc方法，都走到这里了，统一做rpc方法调用的的数据序列化和网络发送
void MprpcChannel::CallMethod(const google::protobuf::MethodDescriptor* method,
                google::protobuf::RpcController* controller, const google::protobuf::Message* request,
                google::protobuf::Message* response, google::protobuf::Closure* done)
{
    const google::protobuf::ServiceDescriptor* sd = method->service();
    std::string service_name = sd->name();  // service_name
    std::string method_name = method->name();   // method_name

    // 获取参数的序列化字符串长度 args_size
    uint32_t args_size = 0;
    std::string args_str;
    if (request->SerializeToString(&args_str))
    {
        args_size = args_str.size();
    }
    else
    {
        controller->SetFailed("Serialize request error!");
        return;
    }

    // 定义rpc的请求header
    mprpc::RpcHeader rpcHeader;
    rpcHeader.set_service_name(service_name);
    rpcHeader.set_method_name(method_name);
    rpcHeader.set_args_size(args_size);

    uint32_t header_size = 0;
    std::string rpc_header_str;
    if (rpcHeader.SerializeToString(&rpc_header_str))
    {
        header_size = rpc_header_str.size();
    }
    else
    {
        controller->SetFailed("Serialize rpc header error!");
        return ;
    }

    // 组织待发送的rpc请求字符串
    std::string send_rpc_str;
    send_rpc_str.insert(0,  std::string((char*)&header_size, 4)); // header_size
    send_rpc_str += rpc_header_str; // rpcheader
    send_rpc_str += args_str;   // args

    // 打印调试信息
    std::cout << "============================================" << std::endl;
    std::cout << "header_size: " << header_size << std::endl;
    std::cout << "rpc_header_str: " << rpc_header_str << std::endl;
    std::cout << "service_name: " << service_name << std::endl;
    std::cout << "method_name: " << method_name << std::endl;
    std::cout << "args_str: " << args_str.c_str() << std::endl;
    std::cout << "============================================" << std::endl;

	    // 使用TCP编程,完成rpc方法远程调用
    int clientfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == clientfd)
    {
        char errtext[512] = {0};
        sprintf(errtext, "create socket error! errno: %d", errno);
        controller->SetFailed(errtext);
        return;
    }

    // 读取配置文件rpcserver的信息
    std::string ip = MprpcApplication::GetInstance().GetConfig().Load("rpcserverip");
    uint16_t port = atoi(MprpcApplication::GetInstance().GetConfig().Load("rpcserverport").c_str());

    std::string ip = host_data.substr(0, idx);
    uint16_t port = atoi(host_data.substr(idx + 1, host_data.size() - idx).c_str());

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    server_addr.sin_addr.s_addr = inet_addr(ip.c_str());

    // 连接rpc服务节点
    if (-1 == connect(clientfd, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    {
        close(clientfd);

        char errtext[1024] = {0};
        sprintf(errtext, "connect error! errno: %d", errno);
        controller->SetFailed(errtext);
        return;
    }

    // 发送rpc请求
    if (-1 == send(clientfd, send_rpc_str.c_str(), send_rpc_str.size(), 0))
    {
        close(clientfd);

        char errtext[1024] = {0};
        sprintf(errtext, "send error! errno: %d", errno);
        controller->SetFailed(errtext);
        return;
    }

    // 接收rpc请求的响应值
    char recv_buf[512] = {0};
    int recv_size = 0;
    if (-1 == (recv_size = recv(clientfd, recv_buf, 512, 0)))
    {
        close(clientfd);

        char errtext[1024] = {0};
        sprintf(errtext, "recv error! errno: %d", errno);
        controller->SetFailed(errtext);
        return;
    }

    //std::string response_str(recv_buf, 0, recv_size);
    //if (!response->ParseFromString(response_str))
    if (!response->ParseFromArray(recv_buf, recv_size))
    {
        std::cout << "parse error! response_str: " << recv_buf << std::endl;
        close(clientfd);

        char errtext[1024] = {0};
        sprintf(errtext, "parse error! response_str: %s", recv_buf);
        controller->SetFailed(errtext);
        return;
    }

    close(clientfd);
}