前言
关于buttonrpc.hpp的解析
server
我们从server.cpp的main函数部分来学习这个hpp文件
int main() {
buttonrpc server;
server.as_server(5555);
//server.bind("redis_command", redis_command);
RedisServer::getInstance()->start();
server.bind("redis_command", &RedisServer::handleClient, RedisServer::getInstance());
// std::cout << "run rpc server on: " << 5555 << std::endl;
server.run();
RedisServer::getInstance()->start();
}
RedisServer::getInstance()->start();顾名思义，声明一个redis实例并启动，这部分不在本文的讨论内容之中。
因此我们先从as_sever,bind,run这三个函数入手，逐步解析butonrpc。
as_server
void buttonrpc::as_server( int port )
{
m_role = RPC_SERVER; //设置角色为服务器
m_socket = new zmq::socket_t(m_context, ZMQ_REP); //创建一个套接字 参数为上下文和套接字类型 //ZMQ_REP 用于请求-应答模式
ostringstream os;
os << "tcp://*:" << port;
m_socket->bind (os.str()); //绑定到指定的地址
}
as_server是初始化一个服务器，将buttonrpc作为的角色设置为服务器。其主体过程就是对zeromq对使用，因此在这之前需要对zeromq有基础的理解。关于zeromq，其链接放在参考部分。
bind
有两个bind函数，根据参数我们很容易得知调用的bind是下面这个函数
template<typename F, typename S>
inline void buttonrpc::bind(std::string name, F func, S* s) //类函数
{
m_handlers[name] = std::bind(&buttonrpc::callproxy<F, S>, this, func, s, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
}
他使用std:bind将函数存进函数映射表。我们再查看一下m_handlers的定义，如下：
std::map<std::string, std::function<void(Serializer*, const char*, int)>> m_handlers; //函数映射表
可以看到定义的key类型为string，而value类型是std:function。
std::function是C++11引入的标准库组件，位于<functional>头文件中。它的主要作用是将可调用对象封装为一个函数对象，提供一种统一的方式来处理各种类型的可调用对象。
那么它是如何与bind对应的呢？
在std:bind中，它将buttonrpc:callproxy<F,S>绑定在this指针，而后续的func，s就是callproxy函数的前两个参数，在这里表示这两个参数的值固定。而后面的三个占位符表示还有三个不固定的参数。这样我们很容易就可以对应上。三个占位符与std:function的三个参数对应。
即Serializer*, const char*, int。
我们跳转到callproxy函数。
callproxy
template<typename F, typename S>
inline void buttonrpc::callproxy(F fun, S * s, Serializer * pr, const char * data, int len)//代理类函数
{
callproxy_(fun, s, pr, data, len);
}
发现第一个参数F fun和第二个参数S *s对应bind的fun和s，那么后三个参数Serializer * pr, const char * data, int len，在std:bind中是三个占位符，并且和m_handlers的std:function中的三个参数完美对应。
因此我们可以了解到，在使用m_handlers时，根据name调用对应的代理函数。
callproxy_
template<typename R, typename C, typename S>
void callproxy_(R(C::* func)(), S* s, Serializer* pr, const char* data, int len) {
callproxy_(std::function<R()>(std::bind(func, s)), pr, data, len);
}
这里利用了std:function函数将func和s绑定到了一起并作为一个新的func传递给另外一个参数不同的callproxy_,我们跟着查看这个函数：
template<typename R>
void buttonrpc::callproxy_(std::function<R()> func, Serializer* pr, const char* data, int len)
{
typename type_xx<R>::type r = call_helper<R>(std::bind(func));
value_t<R> val;
val.set_code(RPC_ERR_SUCCESS);
val.set_val(r);
(*pr) << val;
}
调用了call_helper,而call_helper的内容就是对f函数进行调用，即调用具体的对应的函数。而根据返回值也设定了返回0或者返回f函数的返回值，对应不同的处理。
文件还实现了从无参到五个参数的函数代理使用，其区别就在与参数个数和有参数时需要对参数进行序列化传递。
run
void buttonrpc::run()
{
if (m_role != RPC_SERVER) { //如果不是服务器
return;
}
while (1){
zmq::message_t data; //创建一个消息
recv(data); //接收数据 没消息就阻塞
StreamBuffer iodev((char*)data.data(), data.size());//创建一个流缓冲区
Serializer ds(iodev); //创建一个序列化器
std::string funname;
ds >> funname; //读取函数名
Serializer* r = call_(funname, ds.current(), ds.size()- funname.size()); //调用函数
zmq::message_t retmsg (r->size()); //创建一个消息
memcpy (retmsg.data (), r->data(), r->size()); //拷贝数据
send(retmsg); //发送数据
delete r;
}
}
注释基本将函数解释完毕。这里我们思考一个redis命令的使用，例如set key value。那么从data中读取到的funname就是set。因此call传递的就是set，缓冲区当前字节流的位置current，以及参数的长度ds.size()- funname.size()。
call_
Serializer* buttonrpc::call_(std::string name, const char* data, int len)
{
Serializer* ds = new Serializer(); //创建一个序列化器
if (m_handlers.find(name) == m_handlers.end()) { //如果没有找到函数
(*ds) << value_t<int>::code_type(RPC_ERR_FUNCTIION_NOT_BIND); //设置错误码
(*ds) << value_t<int>::msg_type("function not bind: " + name); //设置错误信息
return ds;
}
auto fun = m_handlers[name]; //获取函数
fun(ds, data, len); //调用函数
ds->reset(); //重置序列号容器
return ds;
}
很明显，因为我们之前存储了对应的函数在m_handlers中，这里可以根据name去查找对应的函数。如果查找到就直接进行函数调用即可。
总结
std:bind和std:function的结合使用，让对这两个c++11特性不熟悉的人会感觉代码理解很困难。但在了解这两个标准组件之后，就比较简单了。
ps:理解简单，让我来写这样的代码感觉就很困难了。
