23、网络编程基础:Boost.Asio、libuv、C++ REST SDK(cpprestsdk)实战

网络编程,说白了就是让程序之间能「说话」。

我做了这么多年C++,发现很多开发者一碰到网络就头大。其实没那么玄乎。今天咱们就聊聊三个主流的网络库:Boost.Asio、libuv,还有微软的C++ REST SDK。

这三个库我都用过,各有各的脾气。我个人习惯是:做高性能服务端用Asio,做事件驱动框架用libuv,写RESTful API就用cpprestsdk。你想想看,选对工具,事半功倍。

23.1 Boost.Asio:C++网络编程的「老大哥」

Boost.Asio是我最早接触的网络库。说实话,刚上手时觉得它挺绕的,但用熟了之后,真香。

23.1.1 核心概念

Asio的核心就两个东西:io_context和socket。io_context负责事件循环,socket负责收发数据。

关键点:Asio支持同步和异步两种模式。我建议你直接学异步,因为这才是Asio的精髓。

23.1.2 实战:一个简单的TCP回显服务器

咱们直接上代码。这个例子我当年面试时写过,后来项目里也经常拿它当模板。

#include <boost/asio.hpp>
#include <iostream>

using boost::asio::ip::tcp;

class Session : public std::enable_shared_from_this<Session> {
public:
    Session(tcp::socket socket) : socket_(std::move(socket)) {}

    void start() {
        do_read();
    }

private:
    void do_read() {
        auto self(shared_from_this());
        socket_.async_read_some(
            boost::asio::buffer(data_, max_length),
            [this, self](boost::system::error_code ec, std::size_t length) {
                if (!ec) {
                    do_write(length);
                }
            });
    }

    void do_write(std::size_t length) {
        auto self(shared_from_this());
        boost::asio::async_write(
            socket_, boost::asio::buffer(data_, length),
            [this, self](boost::system::error_code ec, std::size_t) {
                if (!ec) {
                    do_read();
                }
            });
    }

    tcp::socket socket_;
    enum { max_length = 1024 };
    char data_[max_length];
};

class Server {
public:
    Server(boost::asio::io_context& io_context, short port)
        : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)) {
        do_accept();
    }

private:
    void do_accept() {
        acceptor_.async_accept(
            [this](boost::system::error_code ec, tcp::socket socket) {
                if (!ec) {
                    std::make_shared<Session>(std::move(socket))->start();
                }
                do_accept();
            });
    }

    tcp::acceptor acceptor_;
};

int main() {
    try {
        boost::asio::io_context io_context;
        Server server(io_context, 8888);
        io_context.run();
    } catch (std::exception& e) {
        std::cerr << "Exception: " << e.what() << "\n";
    }
    return 0;
}

我的经验:这里用了shared_from_this来管理Session生命周期。我曾经踩过坑,没处理好这个,导致回调时对象已经被销毁了。嗯,段错误伺候。

23.2 libuv:高性能事件驱动库

libuv是Node.js的底层网络库。我为什么推荐它?因为它跨平台做得特别好,而且API设计得很「C语言风格」,简单直接。

23.2.1 核心概念

libuv的核心是事件循环(uv_loop_t)和句柄(handle)。句柄又分两类:

类型 说明 常见用途
uv_tcp_t TCP句柄 网络通信
uv_timer_t 定时器句柄 超时处理
uv_idle_t 空闲句柄 后台任务
uv_poll_t 轮询句柄 文件描述符监控

23.2.2 实战:用libuv写一个TCP客户端

#include <uv.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

uv_loop_t *loop;
uv_tcp_t client;
uv_connect_t connect_req;

void on_connect(uv_connect_t *req, int status) {
    if (status < 0) {
        fprintf(stderr, "连接失败: %s\n", uv_strerror(status));
        return;
    }
    
    printf("连接成功!\n");
    
    // 发送数据
    char *data = "Hello from libuv!";
    uv_buf_t buf = uv_buf_init(data, strlen(data));
    uv_write_t *write_req = (uv_write_t*)malloc(sizeof(uv_write_t));
    uv_write(write_req, (uv_stream_t*)&client, &buf, 1, NULL);
}

int main() {
    loop = uv_default_loop();
    
    uv_tcp_init(loop, &client);
    
    struct sockaddr_in dest;
    uv_ip4_addr("127.0.0.1", 8888, &dest);
    
    uv_tcp_connect(&connect_req, &client, 
                   (const struct sockaddr*)&dest, on_connect);
    
    uv_run(loop, UV_RUN_DEFAULT);
    
    return 0;
}

注意:libuv的回调函数里不能做耗时操作。我曾经在回调里写了个大循环,结果事件循环直接卡死了。记住,回调里只做轻量操作,重活扔到线程池去。

23.3 C++ REST SDK(cpprestsdk):RESTful API的瑞士军刀

cpprestsdk是微软出的,但跨平台做得不错。我最近几年做微服务,经常用它来写HTTP客户端和服务端。

23.3.1 核心组件

  • http_client:发送HTTP请求
  • http_listener:接收HTTP请求
  • json::value:处理JSON数据
  • pplx::task:异步任务模型

23.3.2 实战:RESTful服务端

#include <cpprest/http_listener.h>
#include <cpprest/json.h>

using namespace web;
using namespace web::http;
using namespace web::http::experimental::listener;

class MyService {
public:
    MyService(const std::string& url) : listener_(url) {
        listener_.support(methods::GET, 
            std::bind(&MyService::handle_get, this, std::placeholders::_1));
        listener_.support(methods::POST, 
            std::bind(&MyService::handle_post, this, std::placeholders::_1));
    }

    void start() {
        listener_.open().wait();
        std::cout << "服务已启动" << std::endl;
    }

private:
    void handle_get(http_request request) {
        json::value response;
        response[U("status")] = json::value::string(U("ok"));
        response[U("message")] = json::value::string(U("Hello from cpprestsdk!"));
        
        request.reply(status_codes::OK, response);
    }

    void handle_post(http_request request) {
        request.extract_json().then([&](json::value body) {
            // 处理JSON数据
            auto name = body[U("name")].as_string();
            std::cout << "收到数据: " << name << std::endl;
            
            json::value response;
            response[U("result")] = json::value::string(U("success"));
            request.reply(status_codes::OK, response);
        }).wait();
    }

    http_listener listener_;
};

int main() {
    MyService service("http://0.0.0.0:8080/api");
    service.start();
    
    std::string line;
    std::getline(std::cin, line);
    
    return 0;
}

避坑指南:cpprestsdk的异步模型基于pplx::task,它和std::future不太一样。我刚开始用的时候,经常忘记调用.wait(),结果程序退出了任务还没执行完。记住,task是惰性求值的,你不等它,它就不跑。

23.4 三个库怎么选?

我列个对比表,你一看就明白了:

特性 Boost.Asio libuv cpprestsdk
语言风格 C++模板 C语言风格 C++现代风格
异步模型 回调+协程 回调 Task-based
适用场景 高性能服务端 事件驱动框架 RESTful API
学习曲线 较陡 中等 平缓
跨平台 优秀 优秀 良好

我个人建议:

  • 如果你做游戏服务器、消息中间件这类高性能场景,选Boost.Asio
  • 如果你在写Node.js插件或者需要轻量级事件循环,选libuv
  • 如果你只是调调RESTful接口,cpprestsdk最省事

23.5 实战建议

最后,分享几个我这些年积累的经验:

  1. 先跑通demo再深入:别一上来就啃文档。把上面的代码跑起来,感受一下每个库的「手感」。
  2. 注意内存管理:网络编程里,内存泄漏是家常便饭。我建议用智能指针管理连接对象,别裸new。
  3. 做好错误处理:网络是不可靠的。我曾经有个项目,上线第一天就因为没处理连接超时,导致整个服务挂了。每个回调都要检查error_code。
  4. 性能调优从IO模型开始:别急着优化代码,先看看你的IO模型对不对。是同步阻塞?还是异步非阻塞?选对了模型,性能就赢了一半。

总结一下:网络编程没有银弹。Boost.Asio、libuv、cpprestsdk各有千秋。我的建议是:三个都试试,找到最适合你项目的那个。毕竟,工具是死的,人是活的。