[实现Rpc] 环境搭建 | JsonCpp | Mudou库 | callBack()

目录

1. 项目介绍

2. 技术选型

3. 开发环境和环境搭建

Ubuntu-22.04环境搭建

1. 安装 wget（一般情况下默认会自带）

2. 更换国内软件源

① 备份原始 /etc/apt/sources.list 文件

② 编辑软件源文件

③ 更新软件包列表

3. 安装常用工具

3.1 安装 lrzsz 传输工具

3.2 安装编译器 gcc/g++

3.3 安装项目构建工具 make

3.4 安装调试器 gdb

3.5 安装版本控制系统 git

3.6 安装 cmake

3.7 安装 jsoncpp

4. 安装 Muduo 库

4. 第三方库使用介绍

4.1 JsonCpp库

4.1.1 Json的数据格式

4.1.2 JsonCpp介绍

4.1.3 JsonCpp使用

4.2 Muduo库

4.2.1 Muduo库是什么

4.2.2 Muduo库常见接口介绍

1. TcpServer 类

2. EventLoop 类

3. TcpConnection 类

4. TcpClient 类

5. Buffer 类

4.2.3 Muduo库的使用

1. 实现英译汉 TCP 服务器

2. 实现英译汉 TCP 客户端

3. Makefile 编译指令

运行结果

回调函数

1. 解耦网络事件处理逻辑

2. 事件驱动的核心机制

3. 提高代码复用性与可维护性

4. 非阻塞与多线程安全

5. 动态响应不同需求

---

1. 项目介绍

（1）

• RPC（Remote Procedure Call）远程过程调用，是⼀种通过网络从远程计算机上请求服务，而不需要了解底层网络通信细节。
• RPC可以使用多种网络协议进行通信， 如HTTP、TCP、UDP等， 并且在TCP/IP网络四层模型中跨越了传输层和应用层。
• 简言之 RPC就是像调用本地方法⼀样调用远程方法。

此过程可以理解为业务处理、计算任务，更直白的说，就是程序/方法/函数等，就是像调用本地放法⼀样调用远程放法。

（2）

举个形象点谈恋爱的例子：

• 本地过程调用：恋爱对象在你的身边， 可以随时约对象吃饭、看电影、约会等等
• 远端过程调用：好像异地恋⼀样， 隔着千山万水， 如果想约会， 需要先和对象进行约定，在坐火车/飞机赶到约定的地点

（3）

⼀个完整RPC通信框架，大概包含以下内容：

• 序列化协议。
• 通信协议。
• 连接复用。
• 服务注册。
• 服务发现。
• 服务订阅和通知。
• 负载均衡。
• 服务监控。
• 同步调用。
• 异步调用。

本项目是基于C++、JsonCpp、muduo网络库实现⼀个简单、易用的RPC通信框架

实现了 同步调用、异步callback调用、异步futrue调用、服务注册/发现/上线/下线，主题发布订阅等功能设计。

---

2. 技术选型

（1）目前RPC的实现方案有两种：

第一种是 client和server继承公共接口：

• 根据IDL（接口描述语言）定义公共接口。
• 编写代码生成器根据IDL语言生成相关的C++、Java代码
• 然后我们的客户端和服务器程序 共同向上继承公共接口即可

比如我们常用的Protobuf、json可以定义IDL接口，并生成RPC相关的代码

• 缺点：使用pb因为生成⼀部分代码， 所以对理解不够友好
• 如果是json定义IDL语言需要自己编写代码⽣成器难度较大一点， 暂不考虑这种方案

第二种实现⼀个远程调用接口call，然后通过传入函数名参数来调用RPC接口。本项目采用这种实现方案。

（2）网络传输的参数和返回值 怎么映射到对应的RPC 接口上？

1. 使用protobuf的反射机制。
2. 使用C++模板、类型萃取、函数萃取等机制。
3. 使用更通用的类型， 比如 JSON类型， 设计好参数和返回值协议即可。

前两种技术难度和学习成本较高， 本项目使用第三种方式。

（3）网络传输怎么做？

• 原生socket - 实现难度较⼤， 暂不考虑。
• Boost asio库的异步通信 - 需要扩展boost库。
• 使用muduo库，学习开发成本较低。

（4）序列化和反序列化？

• Protobuf：可选。
• JSON：因为项⽬需要使⽤JSON来定义函数参数和返回值，所以本项目中 直接采用JSON进行序列化和反序列化。

---

3. 开发环境和环境搭建

• Linux（Centos-7.6 / Ubuntu-22.04）。
• VSCode/Vim。
• g++/gdb。
• Makefile。

Ubuntu-22.04环境搭建

1. 安装 wget（一般情况下默认会自带）

在Ubuntu 22.04中，wget通常已经预安装。如果需要确保它已安装，可以运行以下命令：

sudo apt-get update
sudo apt-get install -y wget

2. 更换国内软件源

为了加速下载速度和提高稳定性，可以将官方的APT源更换为国内镜像源。

① 备份原始 /etc/apt/sources.list 文件

首先备份原来的软件源文件，以防出现问题时可以恢复：

sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak

② 编辑软件源文件

接下来，使用文本编辑器打开并编辑/etc/apt/sources.list文件以添加新的源。推荐使用nano或您喜欢的其他编辑器：

sudo nano /etc/apt/sources.list

然后，在文件中添加或替换以下内容（这里使用了阿里云和清华大学的镜像源）：

deb http://mirrors.aliyun.com/ubuntu/ focal main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ focal main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ focal-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ focal-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ focal-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ focal-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ focal-proposed main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ focal-proposed main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ focal-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ focal-backports main restricted universe multiverse# 添加清华源
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-updates main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-backports main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-security main restricted universe multiverse

请注意，这里的focal是Ubuntu 20.04 LTS的代号。对于Ubuntu 22.04，请根据实际情况更改为jammy。

③ 更新软件包列表

保存更改后，通过以下命令更新APT软件包列表：

sudo apt-get update

3. 安装常用工具

现在可以安装一些常用的开发工具和库。

3.1 安装 lrzsz 传输工具

用于从远程服务器上传和下载文件：

sudo apt-get install lrzsz

3.2 安装编译器 gcc/g++

安装GNU编译器集合，包括C和C++编译器：

sudo apt-get install gcc g++

3.3 安装项目构建工具 make

用于管理和构建项目：

sudo apt-get install make

3.4 安装调试器 gdb

用于调试程序：

sudo apt-get install gdb

3.5 安装版本控制系统 git

用于代码版本管理：

sudo apt-get install git

3.6 安装 cmake

用于跨平台的项目构建系统：

sudo apt-get install cmake

3.7 安装 jsoncpp

用于解析JSON数据格式：

sudo apt-get install libjsoncpp-dev

4. 安装 Muduo 库

1. 下载源码

可以通过 git 命令从 GitHub 克隆 Muduo 的源码到本地：

# 使用 git 克隆源码
git clone https://github.com/chenshuo/muduo.git

2. 安装依赖环境

Muduo 依赖于以下库，需要通过包管理工具安装相关依赖：

# 安装 zlib 和 Boost 库
sudo apt-get install libz-dev libboost-all-dev

3. 编译与安装

执行以下步骤完成编译和安装：

• 解压源码（如适用）：
  如果下载的是压缩包（如 muduo-master.zip），需要先解压。

• unzip muduo-master.zip
  cd muduo-master

• 运行编译脚本：
  使用 build.sh 脚本编译 Muduo 库。

• ./build.sh

• 安装到系统目录：
  运行安装脚本将编译生成的库文件安装到系统路径。

./build.sh install

安装成功：

---

4. 第三方库使用介绍

4.1 JsonCpp库

4.1.1 Json的数据格式

Json简介

Json（JavaScript Object Notation）是一种轻量级的数据交换格式

• 它采用完全独立于编程语言的文本格式来存储和表示数据。
• 这种格式易于人阅读和编写，同时也易于机器解析和生成。

示例：学生信息表示

• C/C++代码表示：

char *name = "xx";
int age = 18;
float score[3] = {88.5, 99, 58};

• Json 表示：

{"姓名" : "xx","年龄" : 18,"成绩" : [88.5, 99, 58],"爱好" :{"书籍" : "西游记","运动" : "打篮球"}
}

Json 的数据类型

• 对象：使用花括号 {} 括起来表示一个对象。
• 数组：使用中括号 [] 括起来表示一个数组。
• 字符串：使用常规双引号 "" 括起来表示一个字符串。
• 数字：包括整形和浮点型，直接使用。

---

4.1.2 JsonCpp介绍

Jsoncpp库概述

Jsoncpp库主要用于实现Json格式数据的序列化和反序列化，即它可以将多个数据对象组织成Json格式字符串，并且可以从Json格式字符串解析得到多个数据对象。

⭕Json 数据对象类 Value

class Json::Value
{Value &operator=(const Value &other); // Value重载了[]和=，因此所有的赋值和获取数据都可以通过简单的方式完成Value& operator[](const std::string& key); // val["name"] = "xx";Value& operator[](const char* key);Value removeMember(const char* key); // 移除元素const Value& operator[](ArrayIndex index) const; // val["score"][0]Value& append(const Value& value); // 添加数组元素 val["score"].append(88);ArrayIndex size() const; // 获取数组元素个数 val["score"].size();std::string asString() const; // 转换为 string string name = val["name"].asString();const char* asCString() const; // 转换为 char* char *name = val["name"].asCString();Int asInt() const; // 转换为 int int age = val["age"].asInt();float asFloat() const; // 转换为 float float weight = val["weight"].asFloat();bool asBool() const; // 转换为 bool bool ok = val["ok"].asBool();
};

序列化接口

class JSON_API StreamWriter 
{virtual int write(Value const& root, std::ostream* sout) = 0;
};class JSON_API StreamWriterBuilder : public StreamWriter::Factory 
{virtual StreamWriter* newStreamWriter() const;
};

反序列化接口

class JSON_API CharReader 
{virtual bool parse(char const* beginDoc, char const* endDoc, Value* root, std::string* errs) = 0;
};class JSON_API CharReaderBuilder : public CharReader::Factory 
{virtual CharReader* newCharReader() const;
};

序列化和反序列化都是需要通过工厂类来进行实例化。

---

4.1.3 JsonCpp使用

代码编写示例

下面是一个简单的例子，展示了如何使用Jsoncpp库进行序列化和反序列化操作。

#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>
#include <sstream>
#include <memory>// 序列化函数
bool serialize(const Json::Value &val, std::string &body)
{std::stringstream ss;Json::StreamWriterBuilder swb;std::unique_ptr<Json::StreamWriter> w(swb.newStreamWriter());bool ret = w->write(val, &ss);if (!ret) return false;body = ss.str();return true;
}// 反序列化函数
bool deserialize(const std::string &body, Json::Value &val)
{Json::CharReaderBuilder crb;std::unique_ptr<Json::CharReader> r(crb.newCharReader());std::string errs;bool ret = r->parse(body.c_str(), body.c_str() + body.size(), &val, &errs);if (!ret) {std::cout << "json unserialize failed : " << errs << std::endl;return false;}return true;
}int main()
{const char* sex = "男";const char* name = "小明";int age = 18;int score[4] = {70, 80, 90};Json::Value stu1;stu1["姓名"] = name;stu1["性别"] = sex;stu1["年龄"] = age;for (auto s : score) {stu1["分数"].append(s);}Json::Value fav;fav["书籍"] = "西游记";fav["运动"] = "打篮球";stu1["爱好"] = fav;std::string body;bool ret1 = serialize(stu1, body);std::cout << body << std::endl;std::string str = R"({"姓名":"小黑", "年龄": 19, "成绩":[32, 45, 56]})";Json::Value stu2;bool ret2 = deserialize(str, stu2);if (!ret2) return -1;std::cout << "姓名: " << stu2["姓名"].asString() << std::endl;std::cout << "年龄: " << stu2["年龄"].asInt() << std::endl;for (int i = 0; i < static_cast<int>(stu2["成绩"].size()); ++i) {std::cout << "成绩: " << stu2["成绩"][i].asFloat() << std::endl;}return 0;
}

⭕注意：对于头文件的包含调用

运行：

---

4.2 Muduo库

4.2.1 Muduo库是什么

Muduo是由陈硕老师开发的 基于非阻塞IO和事件驱动的C++高并发TCP网络编程库。它采用 主从Reactor模型 和 one loop per thread 线程模型。

⭕one loop per thread 的含义：

1. 一个线程只能有一个事件循环（EventLoop），用于响应计时器和IO事件。
2. 一个 文件描述符只能由一个线程进行读写，即一个TCP连接必须归属于某个EventLoop管理。

从而避免了，例如一万个请求就创建一万个线程的等待浪费，主从的结构也将 对于网络连接的接收和对于信息的处理 进行了拆分。

---

4.2.2 Muduo库常见接口介绍

1. TcpServer 类

TcpServer 用于服务端管理和维护 TCP 连接。核心接口包括：

• 构造函数：

TcpServer(EventLoop* loop, const InetAddress& listenAddr, const string& nameArg, Option option = kNoReusePort);

• • 参数：

• • • loop：主EventLoop，用于事件循环。
    • listenAddr：服务器监听地址。
    • nameArg：服务器实例名称。
    • option：是否复用端口。

• 线程设置与启动：

void setThreadNum(int numThreads); // 设置IO线程数量
void start();                      // 启动服务端监听

• 回调函数设置：

void setConnectionCallback(const ConnectionCallback& cb); // 连接建立/断开回调
void setMessageCallback(const MessageCallback& cb);       // 消息接收回调

2. EventLoop 类

EventLoop 是事件循环的核心类。

• 循环控制：

void loop();  // 启动事件循环
void quit();  // 退出事件循环

• 定时器接口：

TimerId runAt(Timestamp time, TimerCallback cb);      // 在指定时间运行回调
TimerId runAfter(double delay, TimerCallback cb);     // 指定延迟后运行回调
TimerId runEvery(double interval, TimerCallback cb);  // 周期性运行回调
void cancel(TimerId timerId);                         // 取消定时器

3. TcpConnection 类

TcpConnection 负责维护单个TCP连接。

• 核心功能：

void send(const void* message, int len);  // 发送数据
void shutdown();                         // 关闭连接

• 上下文管理：

void setContext(const boost::any& context); // 设置上下文
const boost::any& getContext() const;       // 获取上下文

• 回调函数：

void setConnectionCallback(const ConnectionCallback& cb); // 设置连接回调
void setMessageCallback(const MessageCallback& cb);       // 设置消息回调

4. TcpClient 类

TcpClient 用于客户端管理 TCP 连接。

• 核心方法：

void connect();    // 发起连接
void disconnect(); // 断开连接
void stop();       // 停止客户端

• 回调函数：

void setConnectionCallback(ConnectionCallback cb); // 设置连接回调
void setMessageCallback(MessageCallback cb);       // 设置消息回调

• 注意事项：
  由于TcpClient操作是异步的，在连接建立之前尝试发送数据是不被允许的，可通过CountDownLatch进行同步。

5. Buffer 类

Buffer 用于管理数据缓冲区。

• 核心方法：

size_t readableBytes() const;  // 可读数据大小
size_t writableBytes() const;  // 可写数据大小
string retrieveAllAsString();  // 取出所有数据并转为字符串
void append(const char* data, size_t len); // 添加数据
void prepend(const void* data, size_t len); // 在缓冲区头部追加数据

• 内部实现：
  使用std::vector<char>作为缓冲区，支持动态扩容。

---

4.2.3 Muduo库的使用

1. 实现英译汉 TCP 服务器

代码示例：

• 核心逻辑：

• • 使用TcpServer管理服务器。
  • 注册onConnection和onMessage回调函数。
  • 在onMessage中，通过字典查找翻译单词，并返回给客户端。

代码实现：

class DictServer {
public:DictServer(int port):_server(&_baseloop, InetAddress("0.0.0.0", port), "DictServer", TcpServer::kReusePort){_server.setConnectionCallback(std::bind(&DictServer::onConnection, this, std::placeholders::_1));_server.setMessageCallback(std::bind(&DictServer::onMessage, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));}void Start() {_server.start();_baseloop.loop();}private:void onConnection(const TcpConnectionPtr &conn) {if (conn->connected()) std::cout << "连接建立！\n";else std::cout << "连接断开！\n";}void onMessage(const TcpConnectionPtr &conn, Buffer *buf, Timestamp) {std::unordered_map<std::string, std::string> dict = {{"hello", "你好"}, {"world", "世界"}};std::string msg = buf->retrieveAllAsString();conn->send(dict.count(msg) ? dict[msg] : "未知单词！");}private:EventLoop _baseloop;TcpServer _server;
};int main() {DictServer server(8080);server.Start();return 0;
}

2. 实现英译汉 TCP 客户端

代码示例：

• 核心逻辑：

• • 使用TcpClient连接服务器。
  • 注册回调函数onConnection和onMessage。
  • 在建立连接后，通过send方法发送单词。

代码实现：

class DictClient {
public:DictClient(const std::string &ip, int port):_baseloop(_loopthread.startLoop()), _latch(1), _client(_baseloop, InetAddress(ip, port), "DictClient"){_client.setConnectionCallback(std::bind(&DictClient::onConnection, this, std::placeholders::_1));_client.setMessageCallback(std::bind(&DictClient::onMessage, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));_client.connect();_latch.wait();}void send(const std::string &msg) {if (_conn->connected()) _conn->send(msg);else std::cout << "连接断开，发送失败！\n";}private:void onConnection(const TcpConnectionPtr &conn) {if (conn->connected()) {_conn = conn;_latch.countDown();} else {_conn.reset();}}void onMessage(const TcpConnectionPtr &conn, Buffer *buf, Timestamp) {std::cout << buf->retrieveAllAsString() << std::endl;}private:EventLoop *_baseloop;EventLoopThread _loopthread;TcpClient _client;TcpConnectionPtr _conn;CountDownLatch _latch;
};int main() {DictClient client("127.0.0.1", 8080);std::string msg;while (std::cin >> msg) client.send(msg);return 0;
}

3. Makefile 编译指令

CFLAG= -std=c++11 -I ../build/release-install-cpp11/include/
LFLAG= -L../build/release-install-cpp11/lib -lmuduo_net -lmuduo_base -pthreadall: server clientserver: server.cppg++ $(CFLAG) $^ -o $@ $(LFLAG)client: client.cppg++ $(CFLAG) $^ -o $@ $(LFLAG)clean:rm -f server client

---

运行结果

通过简单输入单词实现实时翻译，服务器返回翻译结果或提示“未知单词”。

客户端

回调函数

在 Muduo 中使用回调函数（如 setConnectionCallback 和 setMessageCallback）是为了实现网络库的 事件驱动编程模型，这符合非阻塞 I/O 和高并发网络编程的设计理念。

🔷 为什么要借助回调函数呢：

---

1. 解耦网络事件处理逻辑

Muduo 库本身只负责处理网络事件的底层逻辑，比如连接建立、断开、消息接收等，但具体的业务逻辑是用户的需求（如数据如何处理、何时响应客户端等），而这些需求是 多变且不可预测的。

• 问题：如果将业务逻辑直接嵌入到 Muduo 内部，不仅会导致耦合度过高，还会限制灵活性。
• 解决：通过 回调函数，用户可以将自己的业务逻辑注册给 Muduo，在事件发生时 Muduo 自动调用注册的回调函数。

示例：

• 连接建立或断开时，用户可以通过 setConnectionCallback 注册逻辑来处理事件（如记录日志、初始化资源等）。
• 消息到达时，通过 setMessageCallback 注册回调处理消息（如解析请求、响应客户端）。

---

2. 事件驱动的核心机制

Muduo 的设计基于 事件驱动模型，回调函数是这种模型的核心：

1. 在事件循环（EventLoop）中，Muduo 会监听文件描述符（如 socket）上的事件。
2. 当检测到事件（如新连接、可读数据等），会触发相应的回调函数。

使用回调函数的好处：

• 异步非阻塞：Muduo 不会阻塞等待事件完成，而是注册回调函数后，立即返回继续处理其他事件。
• 灵活性高：用户可以根据业务需要，提供任意逻辑来响应事件，而无需修改框架本身。

示例：

void onConnection(const TcpConnectionPtr& conn) {if (conn->connected()) {std::cout << "新连接建立：" << conn->peerAddress().toIpPort() << std::endl;} else {std::cout << "连接断开" << std::endl;}
}

用户通过 setConnectionCallback 将 onConnection 注册给 TcpServer，当连接建立或断开时，TcpServer 自动调用用户定义的逻辑。

---

3. 提高代码复用性与可维护性

回调函数机制使得：

• 复用性高：Muduo 的底层逻辑和用户的业务逻辑是解耦的，可以分别复用。例如，Muduo 可用于不同类型的服务器（如 HTTP 服务器、聊天服务器），而无需修改核心代码。
• 易于维护：用户只需关心自己的回调函数，不需要深入理解网络库内部的实现。框架和业务逻辑的分离使得代码更清晰易维护。

---

4. 非阻塞与多线程安全

在高并发场景中，回调函数的设计可以帮助 Muduo：

1. 避免阻塞：通过异步回调实现逻辑处理，避免阻塞事件循环线程（EventLoop）。
2. 线程安全：Muduo 使用 one loop per thread 模型，每个线程一个 EventLoop，回调函数在绑定的线程中执行，不需要担心多线程竞态问题。

---

5. 动态响应不同需求

回调函数的动态绑定特性允许用户在运行时根据需求改变逻辑：

• 用户可以在程序启动时或运行时，调用 setConnectionCallback 或 setMessageCallback 设置不同的回调函数，动态调整行为。

示例：

// 设置新的消息回调函数
server.setMessageCallback([](const TcpConnectionPtr& conn, Buffer* buf, Timestamp) {std::string msg = buf->retrieveAllAsString();conn->send("Echo: " + msg);
});

通过新的回调函数，程序逻辑可以轻松从英译汉服务器切换为回声服务器，而无需修改其他部分的代码。

总结

使用回调函数的原因总结如下：

1. 解耦网络库与业务逻辑，增强灵活性。
2. 事件驱动模型的核心机制，支持异步非阻塞操作。
3. 提高复用性与可维护性，框架和业务逻辑分离。
4. 适应高并发需求，避免阻塞并提供线程安全保证。
5. 支持动态逻辑调整，满足运行时多样化需求。

回调函数是事件驱动编程中不可或缺的设计模式，Muduo 通过它实现了高性能、高并发的网络框架设计理念。