首页
/ libhv/libhv API完全指南：从基础函数到高级应用

libhv/libhv API完全指南：从基础函数到高级应用

2026-02-05 05:49:46作者：裴麒琰
libhv
🔥 比libevent/libuv/asio更易用的网络库。A c/c++ network library for developing TCP/UDP/SSL/HTTP/WebSocket/MQTT client/server.
项目地址：https://gitcode.com/libhv/libhv

引言：为什么选择libhv？

在网络编程领域，开发者常常面临选择合适网络库的难题。libevent、libuv、asio等库虽然功能强大，但学习曲线陡峭，API设计复杂。而libhv作为一款新兴的网络库，以其简洁易用的API设计和丰富的功能集，正在迅速获得开发者的青睐。

本文将带领您全面探索libhv的API，从基础函数到高级应用，帮助您快速掌握这个强大网络库的使用技巧。无论您是网络编程新手还是有经验的开发者，阅读本文后，您将能够：

  • 理解libhv的核心架构和设计理念
  • 熟练使用libhv的基础API进行网络编程
  • 掌握TCP/UDP/HTTP/WebSocket等协议的实现
  • 开发高性能的客户端和服务器应用
  • 解决实际项目中可能遇到的技术难题

1. libhv项目结构与核心模块

libhv的项目结构清晰，模块化设计使得各功能组件既相互独立又协同工作。以下是libhv的主要目录结构及其功能说明：

libhv/
├── base/           # 基础功能模块
├── event/          # 事件循环核心
├── http/           # HTTP协议实现
├── examples/       # 示例代码
├── evpp/           # C++封装接口
├── cpputil/        # C++工具类
├── ssl/            # SSL/TLS支持
├── mqtt/           # MQTT协议实现
├── protocol/       # 其他协议支持
└── docs/           # 官方文档

1.1 核心模块概述

libhv的核心功能由以下几个关键模块组成：

  • 基础模块（base）：提供内存管理、字符串操作、线程同步等基础功能
  • 事件循环（event）：实现跨平台的IO多路复用，是libhv的核心
  • 网络接口（net）：封装TCP/UDP socket操作
  • HTTP模块（http）：实现HTTP客户端和服务器
  • WebSocket模块：支持WebSocket协议
  • SSL模块：提供安全传输层支持

下面是libhv核心模块的依赖关系图：

graph TD
    A[基础模块(base)] --> B[事件循环(event)]
    B --> C[网络接口(net)]
    C --> D[HTTP模块(http)]
    C --> E[WebSocket模块]
    C --> F[MQTT模块]
    D --> E
    C --> G[SSL模块]

2. 基础API详解

2.1 基础数据类型与工具函数

libhv提供了一系列基础数据类型和工具函数，位于base/目录下。这些函数为整个库提供了基础支持。

2.1.1 常用数据类型

libhv定义了一些跨平台的数据类型，确保在不同系统上的一致性：

// 来自[base/hdef.h](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/base/hdef.h?utm_source=gitcode_repo_files)
typedef signed char         int8_t;
typedef unsigned char       uint8_t;
typedef short               int16_t;
typedef unsigned short      uint16_t;
typedef int                 int32_t;
typedef unsigned int        uint32_t;
typedef long long           int64_t;
typedef unsigned long long  uint64_t;

typedef int64_t             htime_t;  // 时间戳类型
typedef uint64_t            hthread_t; // 线程ID类型
typedef void*               hv_handle_t; // 句柄类型

2.1.2 内存管理

libhv提供了一套内存管理函数，位于base/hbase.h：

// 内存分配
void* hmalloc(size_t size);
void* hcalloc(size_t nmemb, size_t size);
void* hrealloc(void* ptr, size_t size);
void  hfree(void* ptr);

// 内存池操作
hmem_pool_t* hmem_pool_create(size_t block_size, int pre_alloc);
void*        hmem_pool_alloc(hmem_pool_t* pool, size_t size);
void         hmem_pool_free(hmem_pool_t* pool, void* ptr);
void         hmem_pool_destroy(hmem_pool_t* pool);

2.1.3 字符串操作

libhv提供了丰富的字符串操作函数，定义在cpputil/hstring.h：

// 字符串格式化
std::string format(const char* fmt, ...);

// 字符串分割
std::vector<std::string> split(const std::string& str, const std::string& delim);

// 字符串转换
int         to_int(const std::string& str);
float       to_float(const std::string& str);
double      to_double(const std::string& str);
std::string to_string(int value);
std::string to_string(double value);

// URL编码/解码
std::string url_encode(const std::string& str);
std::string url_decode(const std::string& str);

2.2 事件循环（Event Loop）

事件循环是libhv的核心，位于event/目录。它实现了跨平台的IO多路复用，支持epoll、kqueue、iocp等多种IO模型。

2.2.1 事件循环的创建与运行

// 来自[event/hloop.h](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/event/hloop.h?utm_source=gitcode_repo_files)
hloop_t* hloop_new(int mode);
void hloop_run(hloop_t* loop, int run_mode);
void hloop_free(hloop_t* loop);

使用示例：

#include "hloop.h"

int main() {
    // 创建事件循环实例
    hloop_t* loop = hloop_new(0);
    
    // 运行事件循环
    hloop_run(loop, HLOOP_RUN_DEFAULT);
    
    // 释放资源
    hloop_free(loop);
    return 0;
}

2.2.2 定时器功能

事件循环支持定时器功能，可以用来执行定时任务：

// 来自[event/hloop.h](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/event/hloop.h?utm_source=gitcode_repo_files)
htimer_t* hloop_add_timer(hloop_t* loop, htimer_cb cb, uint32_t ms, int repeat);
int hloop_del_timer(hloop_t* loop, htimer_t* timer);

使用示例：

void on_timer(htimer_t* timer) {
    static int count = 0;
    printf("timer callback %d\n", count++);
    
    if (count >= 5) {
        hloop_del_timer(timer->loop, timer);
    }
}

int main() {
    hloop_t* loop = hloop_new(0);
    
    // 添加定时器，每隔1秒执行一次，重复5次
    hloop_add_timer(loop, on_timer, 1000, 1);
    
    hloop_run(loop, HLOOP_RUN_DEFAULT);
    hloop_free(loop);
    return 0;
}

3. 网络编程基础

3.1 TCP编程

libhv提供了简洁易用的TCP编程接口，支持客户端和服务器模式。

3.1.1 TCP服务器

创建TCP服务器的基本步骤：

  1. 创建事件循环
  2. 创建TCP服务器
  3. 设置连接回调函数
  4. 启动服务器
// 来自[examples/tcp_echo_server.c](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/tcp_echo_server.c?utm_source=gitcode_repo_files)
#include "hloop.h"
#include "hsocket.h"

void on_close(hio_t* io) {
    printf("connection closed\n");
}

void on_recv(hio_t* io, void* buf, int readbytes) {
    // 回显数据
    hio_write(io, buf, readbytes);
}

void on_accept(hio_t* io) {
    printf("new connection: %s:%d\n", hio_remote_ip(io), hio_remote_port(io));
    
    // 设置接收回调
    hio_setcb_read(io, on_recv);
    // 设置关闭回调
    hio_setcb_close(io, on_close);
    // 开始读取数据
    hio_read(io);
}

int main() {
    hloop_t* loop = hloop_new(0);
    
    // 创建TCP服务器，监听8080端口
    hio_t* listen_io = hloop_create_tcp_server(loop, "0.0.0.0", 8080, on_accept);
    if (listen_io == NULL) {
        return -1;
    }
    
    printf("tcp echo server listen on 0.0.0.0:8080\n");
    hloop_run(loop, HLOOP_RUN_DEFAULT);
    hloop_free(loop);
    return 0;
}

3.1.2 TCP客户端

TCP客户端的使用同样简单：

// 来自[examples/tcp_client_test.c](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/tcp_client_test.c?utm_source=gitcode_repo_files)
#include "hloop.h"
#include "hsocket.h"

void on_close(hio_t* io) {
    printf("connection closed\n");
}

void on_recv(hio_t* io, void* buf, int readbytes) {
    printf("recv: %.*s\n", readbytes, (char*)buf);
}

void on_connect(hio_t* io, int err) {
    if (err != 0) {
        printf("connect error: %d\n", err);
        return;
    }
    
    printf("connect success\n");
    hio_setcb_read(io, on_recv);
    hio_setcb_close(io, on_close);
    hio_read(io);
    
    // 发送数据
    const char* msg = "hello, libhv!";
    hio_write(io, msg, strlen(msg));
}

int main() {
    hloop_t* loop = hloop_new(0);
    
    // 连接到服务器
    hloop_create_tcp_client(loop, "127.0.0.1", 8080, on_connect);
    
    hloop_run(loop, HLOOP_RUN_DEFAULT);
    hloop_free(loop);
    return 0;
}

3.2 UDP编程

除了TCP，libhv也提供了UDP协议的支持。

// 来自[examples/udp_echo_server.c](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/udp_echo_server.c?utm_source=gitcode_repo_files)
#include "hloop.h"
#include "hsocket.h"

void on_udp_recv(hio_t* io, void* buf, int readbytes, struct sockaddr* peeraddr, socklen_t peerlen) {
    // 回显数据
    hio_udp_sendto(io, buf, readbytes, peeraddr, peerlen);
}

int main() {
    hloop_t* loop = hloop_new(0);
    
    // 创建UDP服务器
    hio_t* io = hloop_create_udp_server(loop, "0.0.0.0", 8080, on_udp_recv);
    if (io == NULL) {
        return -1;
    }
    
    printf("udp echo server listen on 0.0.0.0:8080\n");
    hloop_run(loop, HLOOP_RUN_DEFAULT);
    hloop_free(loop);
    return 0;
}

4. HTTP编程

HTTP是libhv的核心功能之一，提供了完整的HTTP客户端和服务器实现。

4.1 HTTP服务器

libhv的HTTP服务器API设计简洁而强大，支持路由、中间件、静态文件服务等功能。

4.1.1 基本HTTP服务器

// 来自[examples/http_server_test.cpp](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/http_server_test.cpp?utm_source=gitcode_repo_files)
#include "HttpServer.h"

using namespace hv;

int main(int argc, char** argv) {
    int port = 8080;
    if (argc > 1) {
        port = atoi(argv[1]);
    }

    HttpService router;
    
    // 静态文件服务
    router.Static("/", "./html");
    
    // API路由
    router.GET("/ping", [](const HttpContextPtr& ctx) {
        return ctx->send("pong");
    });
    
    router.GET("/get", [](const HttpContextPtr& ctx) {
        Json resp;
        resp["origin"] = ctx->ip();
        resp["url"] = ctx->url();
        resp["args"] = ctx->params();
        resp["headers"] = ctx->headers();
        return ctx->send(resp.dump(2));
    });
    
    router.POST("/echo", [](const HttpContextPtr& ctx) {
        return ctx->send(ctx->body(), ctx->type());
    });
    
    // 路径参数
    router.GET("/user/{id}", [](const HttpContextPtr& ctx) {
        Json resp;
        resp["id"] = ctx->param("id");
        return ctx->send(resp.dump(2));
    });
    
    // 启用CORS
    router.AllowCORS();
    
    HttpServer server;
    server.service = &router;
    server.port = port;
    
    // 启动服务器
    server.start();
    
    printf("HTTP server running on http://0.0.0.0:%d\n", port);
    printf("Press Enter to stop...\n");
    getchar();
    
    return 0;
}

4.1.2 路由系统

libhv的HTTP服务器提供了灵活的路由系统，支持多种路由匹配方式：

// 精确匹配
router.GET("/", handler);

// 参数路由
router.GET("/user/{id}", user_handler);

// 通配符路由
router.GET("/static/*", static_handler);

// 正则路由
router.GET("/article/(\\d+)", article_handler);

// 任意HTTP方法
router.ANY("/api/*", api_handler);

4.1.3 中间件

中间件是处理HTTP请求的拦截器，可以在请求到达处理器之前或之后执行一些操作：

// 日志中间件
router.Use([](const HttpContextPtr& ctx) {
    auto start = hv::steady_clock::now();
    
    // 调用下一个中间件或处理器
    ctx->next(start {
        auto end = hv::steady_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        
        printf("[%s] %s %s %d %lldus\n", 
               ctx->ip().c_str(),
               ctx->methodString(),
               ctx->url().c_str(),
               ctx->response()->status_code,
               (long long)duration.count());
    });
});

4.2 HTTP客户端

libhv提供了功能完善的HTTP客户端，支持同步和异步请求。

4.2.1 同步请求

// 来自[examples/http_client_test.cpp](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/http_client_test.cpp?utm_source=gitcode_repo_files)
#include "HttpClient.h"

int main() {
    HttpClient cli;
    
    // 发送GET请求
    HttpRequest req;
    req.url = "http://httpbin.org/get";
    HttpResponse resp;
    int ret = cli.send(&req, &resp);
    if (ret != 0) {
        printf("request failed: %d\n", ret);
        return -1;
    }
    
    printf("status: %d\n", resp.status_code);
    printf("headers:\n%s\n", resp.headers.dump().c_str());
    printf("body:\n%s\n", resp.body.c_str());
    
    return 0;
}

4.2.2 异步请求

异步请求不会阻塞当前线程，适合高性能场景：

// 来自[examples/http_client_test.cpp](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/http_client_test.cpp?utm_source=gitcode_repo_files)
void test_http_async_client(HttpClient* cli) {
    auto req = std::make_shared<HttpRequest>();
    req->method = HTTP_POST;
    req->url = "http://127.0.0.1:8080/echo";
    req->headers["Connection"] = "keep-alive";
    req->body = "This is an async request.";
    req->timeout = 10;
    
    cli->sendAsync(req, [](const HttpResponsePtr& resp) {
        if (resp == NULL) {
            printf("request failed!\n");
        } else {
            printf("%d %s\n", resp->status_code, resp->status_message());
            printf("%s\n", resp->body.c_str());
        }
    });
}

4.2.3 便捷HTTP请求函数

libhv还提供了类似Python requests库的便捷API：

// 来自[http/client/requests.h](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/http/client/requests.h?utm_source=gitcode_repo_files)
// GET请求
HttpResponsePtr requests::get(const std::string& url, const http_headers& headers = {});

// POST请求
HttpResponsePtr requests::post(const std::string& url, const std::string& body = "", const http_headers& headers = {});

// 下载文件
size_t requests::downloadFile(const std::string& url, const std::string& filename);

// 上传文件
HttpResponsePtr requests::uploadFile(const std::string& url, const std::string& filename, const std::string& formname = "file");

使用示例：

// 来自[examples/http_client_test.cpp](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/http_client_test.cpp?utm_source=gitcode_repo_files)
#include "requests.h"

void test_requests() {
    // GET请求
    auto resp = requests::get("http://httpbin.org/get");
    if (resp) {
        printf("GET: %d %s\n", resp->status_code, resp->body.c_str());
    }
    
    // POST JSON数据
    Json j;
    j["name"] = "libhv";
    j["version"] = "1.0.0";
    http_headers headers;
    headers["Content-Type"] = "application/json";
    resp = requests::post("http://httpbin.org/post", j.dump(), headers);
    if (resp) {
        printf("POST: %d %s\n", resp->status_code, resp->body.c_str());
    }
    
    // 下载文件
    size_t filesize = requests::downloadFile("http://httpbin.org/image/png", "image.png");
    if (filesize > 0) {
        printf("Downloaded %zu bytes\n", filesize);
    }
}

5. WebSocket编程

WebSocket是一种在单个TCP连接上进行全双工通信的协议，libhv提供了完整的WebSocket支持。

5.1 WebSocket服务器

// 来自[examples/websocket_server_test.cpp](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/websocket_server_test.cpp?utm_source=gitcode_repo_files)
#include "WebSocketServer.h"

using namespace hv;

int main(int argc, char** argv) {
    int port = 9999;
    if (argc > 1) {
        port = atoi(argv[1]);
    }

    HttpService http;
    http.GET("/ping", [](const HttpContextPtr& ctx) {
        return ctx->send("pong");
    });

    WebSocketService ws;
    ws.onopen = [](const WebSocketChannelPtr& channel, const HttpRequestPtr& req) {
        printf("onopen: GET %s\n", req->Path().c_str());
        // 发送欢迎消息
        channel->send("Welcome to libhv websocket server!");
    };

    ws.onmessage = [](const WebSocketChannelPtr& channel, const std::string& msg) {
        printf("onmessage: %s\n", msg.c_str());
        // 回显消息
        channel->send(msg);
    };

    ws.onclose = [](const WebSocketChannelPtr& channel) {
        printf("onclose\n");
    };

    WebSocketServer server;
    server.port = port;
    server.registerHttpService(&http);
    server.registerWebSocketService(&ws);

    server.start();
    printf("WebSocket server running on ws://0.0.0.0:%d\n", port);
    printf("Press Enter to stop...\n");
    getchar();
    return 0;
}

5.2 WebSocket客户端

// 来自[examples/websocket_client_test.cpp](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/websocket_client_test.cpp?utm_source=gitcode_repo_files)
#include "WebSocketClient.h"

using namespace hv;

class MyWebSocketClient : public WebSocketClient {
public:
    MyWebSocketClient(EventLoopPtr loop = NULL) : WebSocketClient(loop) {}
    
    int connect(const char* url) {
        onopen = []() {
            printf("onopen\n");
        };
        
        onmessage = this {
            printf("onmessage: %s\n", msg.c_str());
        };
        
        onclose = []() {
            printf("onclose\n");
        };
        
        // 设置重连策略
        reconn_setting_t reconn;
        reconn_setting_init(&reconn);
        reconn.min_delay = 1000;
        reconn.max_delay = 10000;
        reconn.delay_policy = 2;
        setReconnect(&reconn);
        
        return WebSocketClient::open(url);
    }
};

int main(int argc, char** argv) {
    if (argc < 2) {
        printf("Usage: %s url\n", argv[0]);
        return -1;
    }
    const char* url = argv[1];

    MyWebSocketClient ws;
    ws.connect(url);

    std::string input;
    while (std::getline(std::cin, input)) {
        if (input == "exit") break;
        ws.send(input);
    }

    return 0;
}

6. 高级应用

6.1 多线程与线程池

libhv提供了线程池和异步任务执行功能，可以轻松实现并行处理。

// 来自[cpputil/hthreadpool.h](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/cpputil/hthreadpool.h?utm_source=gitcode_repo_files)
#include "hthreadpool.h"

int main() {
    // 创建线程池，4个工作线程
    ThreadPool pool(4);
    
    // 提交任务
    for (int i = 0; i < 8; ++i) {
        pool.submit([i]() {
            printf("task %d running in thread %ld\n", i, hv_gettid());
            hv_delay(100);
        });
    }
    
    // 等待所有任务完成
    pool.join();
    return 0;
}

6.2 SSL/TLS加密通信

libhv支持SSL/TLS加密通信，可用于HTTPS和WSS（WebSocket Secure）。

// 来自[examples/http_server_test.cpp](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/http_server_test.cpp?utm_source=gitcode_repo_files)
#if TEST_HTTPS
    server.https_port = 8443;
    hssl_ctx_opt_t param;
    memset(&param, 0, sizeof(param));
    param.crt_file = "cert/server.crt";
    param.key_file = "cert/server.key";
    param.endpoint = HSSL_SERVER;
    if (server.newSslCtx(&param) != 0) {
        fprintf(stderr, "new SSL_CTX failed!\n");
        return -20;
    }
#endif

6.3 配置文件解析

libhv提供了INI配置文件解析功能，可以方便地读取配置文件。

// 来自[cpputil/iniparser.h](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/cpputil/iniparser.h?utm_source=gitcode_repo_files)
#include "iniparser.h"

int main() {
    IniParser ini;
    ini.load("config.ini");
    
    // 读取配置
    int port = ini.getInt("server", "port", 8080);
    std::string log_level = ini.getString("log", "level", "info");
    bool daemon = ini.getBool("server", "daemon", false);
    
    printf("port: %d\n", port);
    printf("log_level: %s\n", log_level.c_str());
    printf("daemon: %s\n", daemon ? "true" : "false");
    
    return 0;
}

7. 性能优化与最佳实践

7.1 事件循环配置

合理配置事件循环可以显著提高性能：

// 设置事件循环线程数
server.setThreadNum(4);

// 设置IO线程数
server.setIOThreadNum(2);

// 设置工作线程数（处理业务逻辑）
server.setWorkerThreadNum(4);

7.2 连接管理

对于高并发服务器，合理的连接管理策略至关重要：

// 设置最大连接数
server.setMaxConnections(100000);

// 设置连接超时
server.setIdleTimeout(60); // 60秒

// 设置TCP keepalive
server.setTCPKeepAlive(true);

7.3 内存管理

libhv提供了内存池功能，可以减少内存分配开销：

// 使用内存池分配内存
hmem_pool_t* pool = hmem_pool_create(4096, 1024); // 4KB块，预分配1024个
void* buf = hmem_pool_alloc(pool, 1024);
// 使用buf...
hmem_pool_free(pool, buf);
hmem_pool_destroy(pool);

8. 实际应用案例

8.1 反向代理服务器

libhv可以轻松实现一个简单的反向代理服务器：

// 来自[examples/tinyproxyd.c](https://gitcode.com/libhv/libhv/blob/e2ba81baa2fd782a13ce4b2be7c181d8966442d4/examples/tinyproxyd.c?utm_source=gitcode_repo_files)
#include "hloop.h"
#include "hsocket.h"

#define BUF_SIZE 8192

typedef struct {
    hio_t* client;
    hio_t* server;
} proxy_t;

void server_on_close(hio_t* io) {
    proxy_t* proxy = (proxy_t*)hio_get_userdata(io);
    if (proxy->client) {
        hio_close(proxy->client);
    }
    free(proxy);
}

void client_on_close(hio_t* io) {
    proxy_t* proxy = (proxy_t*)hio_get_userdata(io);
    if (proxy->server) {
        hio_close(proxy->server);
    }
    free(proxy);
}

void server_on_recv(hio_t* io, void* buf, int readbytes) {
    proxy_t* proxy = (proxy_t*)hio_get_userdata(io);
    hio_write(proxy->client, buf, readbytes);
}

void client_on_recv(hio_t* io, void* buf, int readbytes) {
    proxy_t* proxy = (proxy_t*)hio_get_userdata(io);
    hio_write(proxy->server, buf, readbytes);
}

void on_connect(hio_t* server_io, int err) {
    if (err != 0) {
        printf("connect error: %d\n", err);
        return;
    }

    proxy_t* proxy = (proxy_t*)hio_get_userdata(server_io);
    proxy->server = server_io;

    hio_setcb_read(server_io, server_on_recv);
    hio_setcb_close(server_io, server_on_close);
    hio_read(server_io);
}

void on_accept(hio_t* client_io) {
    char* host = "127.0.0.1";
    int port = 8080;

    proxy_t* proxy = (proxy_t*)malloc(sizeof(proxy_t));
    memset(proxy, 0, sizeof(proxy_t));
    proxy->client = client_io;

    hio_set_userdata(client_io, proxy);
    hio_setcb_read(client_io, client_on_recv);
    hio_setcb_close(client_io, client_on_close);
    hio_read(client_io);

    hloop_t* loop = hio_loop(client_io);
    hio_t* server_io = hloop_create_tcp_client(loop, host, port, on_connect);
    hio_set_userdata(server_io, proxy);
}

int main() {
    hloop_t* loop = hloop_new(0);
    hio_t* listen_io = hloop_create_tcp_server(loop, "0.0.0.0", 80, on_accept);
    if (listen_io == NULL) {
        return -1;
    }
    printf("tinyproxyd listen on 0.0.0.0:80, forward to %s:%d\n", "127.0.0.1", 8080);
    hloop_run(loop, HLOOP_RUN_DEFAULT);
    hloop_free(loop);
    return 0;
}

8.2 WebSocket聊天服务器

使用libhv可以快速实现一个WebSocket聊天服务器：

// 简化版聊天服务器
#include "WebSocketServer.h"
#include <set>

using namespace hv;

std::set<WebSocketChannelPtr> clients;
std::mutex clients_mutex;

int main() {
    WebSocketService ws;
    
    ws.onopen = [](const WebSocketChannelPtr& channel) {
        std::lock_guard<std::mutex> lock(clients_mutex);
        clients.insert(channel);
        printf("new client, total: %zu\n", clients.size());
    };
    
    ws.onmessage = [](const WebSocketChannelPtr& channel, const std::string& msg) {
        std::lock_guard<std::mutex> lock(clients_mutex);
        // 广播消息
        for (auto it = clients.begin(); it != clients.end();) {
            auto cli = *it;
            if (cli->isConnected()) {
                cli->send(msg);
                ++it;
            } else {
                it = clients.erase(it);
            }
        }
    };
    
    ws.onclose = [](const WebSocketChannelPtr& channel) {
        std::lock_guard<std::mutex> lock(clients_mutex);
        clients.erase(channel);
        printf("client left, total: %zu\n", clients.size());
    };
    
    WebSocketServer server;
    server.port = 9999;
    server.registerWebSocketService(&ws);
    server.start();
    
    printf("Chat server running on ws://0.0.0.0:9999\n");
    getchar();
    return 0;
}

9. 总结与展望

9.1 核心功能回顾

libhv作为一款高性能网络库，提供了丰富的API和功能：

  • 跨平台的事件循环实现
  • 简洁易用的TCP/UDP API
  • 完整的HTTP客户端/服务器实现
  • WebSocket协议支持
  • SSL/TLS加密通信
  • 线程池和异步任务处理
  • 配置文件解析

9.2 学习资源与社区支持

9.3 未来发展方向

libhv团队持续改进和扩展库的功能，未来可能包括：

  • gRPC协议支持
  • HTTP/3支持
  • 更多协议实现
  • 性能优化和新特性

附录：常用API速查表

事件循环API

函数名 描述
hloop_new() 创建事件循环实例
hloop_run() 运行事件循环
hloop_free() 释放事件循环资源
hloop_add_timer() 添加定时器
hloop_del_timer() 删除定时器

HTTP服务器API

函数名 描述
HttpServer::start() 启动HTTP服务器
HttpService::GET() 注册GET路由
HttpService::POST() 注册POST路由
HttpService::Static() 设置静态文件服务
HttpService::Proxy() 设置反向代理

HTTP客户端API

函数名 描述
HttpClient::send() 发送同步HTTP请求
HttpClient::sendAsync() 发送异步HTTP请求
requests::get() 便捷GET请求
requests::post() 便捷POST请求
requests::downloadFile() 下载文件

WebSocket API

函数名 描述
WebSocketServer::registerWebSocketService() 注册WebSocket服务
WebSocketChannel::send() 发送WebSocket消息
WebSocketClient::open() 连接WebSocket服务器
WebSocketClient::send() 发送客户端消息

通过本文的介绍，相信您已经对libhv的API有了全面的了解。libhv以其简洁的设计和强大的功能，为网络编程提供了高效的解决方案。无论是开发简单的网络工具还是构建高性能的服务器应用，libhv都是一个值得考虑的选择。

希望本文能够帮助您更好地理解和使用libhv，在实际项目中发挥其优势。祝您编程愉快！

libhv
🔥 比libevent/libuv/asio更易用的网络库。A c/c++ network library for developing TCP/UDP/SSL/HTTP/WebSocket/MQTT client/server.
项目地址：https://gitcode.com/libhv/libhv
登录后查看全文

相关内容推荐

1 libhv 开源项目教程2 在libhv项目中实现嵌入式Web管理界面的方法3 libhv项目中同步通信的实现方式解析4 libhv项目中HttpServer定时器与事件循环的高级应用5 【亲测免费】 探索libhv：一款高效、轻量级的多线程库6 在Windows中使用MinGW-w64编译libhv项目时解决ThreadLocalStorage未定义问题7 libhv日志管理：自动清理过期日志文件的最佳实践8 libhv项目中WebSocket客户端链接错误的解决方案9 libhv项目中定时器使用不当导致崩溃问题分析10 libhv项目中GetCookie函数处理多值Cookie的问题分析
热门项目推荐
相关项目推荐

热门内容推荐

1 【亲测免费】 开源项目 `build-your-own-x` 使用指南2 【亲测免费】 探索科技之旅：《Build Your Own X》项目详解3 GitHub_Trending/bu/build-your-own-x自动化：CI/CD流程在自制项目中的应用4 从零打造智能家居系统：用build-your-own-x实现家庭自动化

最新内容推荐

MsgViewer终极指南：轻松打开MSG文件的免费邮件查看器PiliPlus终极体验指南：解锁B站第三方客户端的完整功能秘籍Shutter Encoder视频转换神器：从小白到高手的效率革命直播抢码实战秘籍：5步搞定智能扫码登录，成功率提升300%如何快速掌握SillyTavern版本更新：新手必看的完整操作手册Calibre路径保护插件：告别拼音目录，拥抱原生中文路径5分钟快速上手：文泉驿微米黑字体跨平台安装完整指南终极歌词下载指南：3大平台免费获取，打造完美音乐体验PDown百度网盘下载器：2025年免费极速下载解决方案终极YimMenu游戏增强工具：从安装到精通完整指南

项目优选

收起
kernelkernel
deepin linux kernel
C
27
11
docsdocs
OpenHarmony documentation | OpenHarmony开发者文档
Dockerfile
532
3.74 K
kernelkernel
openEuler内核是openEuler操作系统的核心，既是系统性能与稳定性的基石，也是连接处理器、设备与服务的桥梁。
C
336
178
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
886
596
pytorchpytorch
Ascend Extension for PyTorch
Python
340
403
flutter_flutterflutter_flutter
暂无简介
Dart
771
191
nop-entropynop-entropy
Nop Platform 2.0是基于可逆计算理论实现的采用面向语言编程范式的新一代低代码开发平台，包含基于全新原理从零开始研发的GraphQL引擎、ORM引擎、工作流引擎、报表引擎、规则引擎、批处理引引擎等完整设计。nop-entropy是它的后端部分，采用java语言实现，可选择集成Spring框架或者Quarkus框架。中小企业可以免费商用
Java
12
1
agent-studioagent-studio
openJiuwen agent-studio提供零码、低码可视化开发和工作流编排，模型、知识库、插件等各资源管理能力
TSX
986
247
Cangjie-ExamplesCangjie-Examples
本仓将收集和展示高质量的仓颉示例代码，欢迎大家投稿，让全世界看到您的妙趣设计，也让更多人通过您的编码理解和喜爱仓颉语言。
Cangjie
416
4.21 K
ohos_react_nativeohos_react_native
React Native鸿蒙化仓库
JavaScript
303
355