Nginx基础教程（7）Nginx开发准备之C++包装类：拒绝C指针恐怖片！用C++优雅“驯服”Nginx，代码洁癖患者福音-优快云博客

Nginx开发准备之C++包装类

引言：当Nginx遇上C++，一场美丽的“意外”

兄弟们，搞过Nginx模块开发的举个手？我仿佛已经看到了你们皱起的眉头和那写满“痛苦”的眼神。没错，Nginx本身是个性能怪兽，但它的开发模式，还停留在那个充满void*、手动内存管理和冗长函数名的“C语言远古时代”。

你是不是也经历过这种绝望：

ngx_str_t用起来束手束脚，一不小心就内存越界。
那个神秘的ngx_http_request_t *r，像个百宝箱，也是个大坑，里面的字段多到让人怀疑人生。
最要命的是，每个资源都得小心翼翼地分配和释放，一个瞌睡，内存泄漏和野指针就来找你聊天了。

说好的“编程乐趣”呢？全变成了“调试噩梦”。

别慌！今天，我就是来给大家送“降压药”的。咱们不改变Nginx的内核，而是在它之上，用C++搭建一层“舒适区”。通过设计和运用C++包装类，我们能像在现代都市开自动驾驶汽车一样，安全、舒适地驾驭Nginx这头性能猛兽。

第一章：为什么是C++？给Nginx来一次“代码精装修”

你可能会问：“Nginx用C写得好好的，为啥要折腾C++？” 问得好！这就好比问你：“毛坯房也能住，为啥要装修？”

RAII：自动化的管家婆
C++的“资源获取即初始化”原则，是我们的王牌。简单说，就是让对象的构造和析构函数去自动管理资源（内存、文件句柄等）。ngx_palloc申请的内存？交给包装类，它析构时自动ngx_pfree。你再也不用在函数的每个错误返回处手动清理了，从此和“忘了释放”说拜拜。
封装：给复杂结构穿上“制服”
把ngx_str_t、ngx_list_t、ngx_table_elt_t（Header）这些“裸奔”的结构体，用类包装起来。给它们加上安全的API，比如.length()， .c_str()，甚至重载操作符==、+，让操作字符串像用STL一样爽。
类型安全：让编译器当你的“保镖”
C里面动不动就void*，编译器只能干瞪眼。C++通过强类型和模板，能在编译阶段就抓住很多“张冠李戴”的类型错误，把bug扼杀在摇篮里。
可读性与可维护性：代码是写给人看的
request.getHeader("User-Agent") 和 ngx_http_get_header_field(r, &ngx_http_user_agent)，你觉得哪个更清晰？当你的业务逻辑被清晰的C++对象和函数调用包裹，代码的自解释性会极大提升，三个月后你再看，依然能秒懂。

第二章：设计我们的“瑞士军刀”——核心包装类蓝图

理论吹得天花乱坠，不如动手画图纸。我们来设计几个最核心的包装类。

1. NgxString：告别ngx_str_t的原始社会

原始的ngx_str_t就两个字段：data和len。我们要把它升级成“智能字符串”。

#ifndef NGX_STRING_HPP
#define NGX_STRING_HPP

#include <ngx_core.h>
#include <string>

class NgxString {
private:
    ngx_str_t m_str;

public:
    // 构造函数们：适应各种场景
    NgxString() { m_str.data = nullptr; m_str.len = 0; }
    NgxString(ngx_str_t & str) : m_str(str) {} // 引用现有内存
    NgxString(ngx_pool_t * pool, const std::string & s) {
        // 从std::string深拷贝，使用Nginx内存池
        m_str.data = (u_char *)ngx_palloc(pool, s.size());
        m_str.len = s.size();
        ngx_memcpy(m_str.data, s.c_str(), s.size());
    }

    // 空判断
    bool empty() const { return m_str.data == nullptr || m_str.len == 0; }
    // 获取长度
    size_t length() const { return m_str.len; }
    // 安全的获取C风格字符串（保证以'\0'结尾，需在内存池分配时预留空间）
    const char * c_str() const { return m_str.data ? reinterpret_cast<const char*>(m_str.data) : ""; }

    // 类型转换操作符，方便需要原版ngx_str_t的地方
    operator ngx_str_t() const { return m_str; }
    operator ngx_str_t*() { return &m_str; }

    // 比较操作符重载
    bool operator==(const NgxString & other) const {
        if (m_str.len != other.m_str.len) return false;
        return ngx_strncmp(m_str.data, other.m_str.data, m_str.len) == 0;
    }

    // 转换成std::string（方便使用C++算法）
    std::string toStdString() const {
        return empty() ? std::string() : std::string(c_str(), length());
    }
};

#endif // NGX_STRING_HPP

看，有了这个类，我们就能安全、直观地操作字符串了！

2. NgxRequest：核心请求对象的“全能秘书”

ngx_http_request_t *r是万恶之源，也是万能之源。我们来给它配个秘书。

#ifndef NGX_REQUEST_HPP
#define NGX_REQUEST_HPP

#include <ngx_http.h>
#include "NgxString.hpp"
#include <map>

class NgxRequest {
private:
    ngx_http_request_t *m_r;

public:
    NgxRequest(ngx_http_request_t * r) : m_r(r) {}

    // 获取方法 (GET, POST, ...)
    NgxString getMethod() const {
        return NgxString(m_r->method_name);
    }

    // 获取URI
    NgxString getUri() const {
        return NgxString(m_r->uri);
    }

    // 获取指定Header，比如 getHeader("Host")
    NgxString getHeader(const std::string & key) const {
        ngx_table_elt_t *header = m_r->headers_in.headers;
        if (header) {
            for (; header; header = header->next) {
                NgxString headerName(header->key);
                if (headerName.toStdString() == key) {
                    return NgxString(header->value);
                }
            }
        }
        return NgxString(); // 返回空对象
    }

    // 获取所有Header（返回一个map，方便查找）
    std::map<std::string, std::string> getAllHeaders() const {
        std::map<std::string, std::string> headers;
        ngx_table_elt_t *h = m_r->headers_in.headers;
        for (; h; h = h->next) {
            headers[NgxString(h->key).toStdString()] = NgxString(h->value).toStdString();
        }
        return headers;
    }

    // 获取查询参数 (简单实现，复杂情况需解析args)
    NgxString getArgs() const {
        return NgxString(m_r->args);
    }

    // 获取请求体 (这是一个简化版，实际需要处理异步读取)
    NgxString getRequestBody() const {
        // 注意：这仅在请求体已被完整读取到内存中时有效
        if (m_r->request_body && m_r->request_body->buf) {
            return NgxString(m_r->request_body->buf->pos, m_r->request_body->buf->last - m_r->request_body->buf->pos);
        }
        return NgxString();
    }

    // 设置返回状态码
    void setStatus(ngx_uint_t status) const {
        m_r->headers_out.status = status;
    }

    // 设置返回的Content-Type
    void setContentType(const NgxString & type) const {
        m_r->headers_out.content_type = type; // 这里利用了我们的类型转换操作符
    }

    // 发送Header
    ngx_int_t sendHeader() const {
        return ngx_http_send_header(m_r);
    }

    // 发送Body
    ngx_int_t sendBody(const NgxString & data) const {
        ngx_buf_t *b = ngx_create_temp_buf(m_r->pool, data.length());
        if (b == nullptr) return NGX_ERROR;
        ngx_memcpy(b->pos, data.c_str(), data.length());
        b->last = b->pos + data.length();
        b->last_buf = 1; // 这是最后一个buffer

        ngx_chain_t out;
        out.buf = b;
        out.next = nullptr;

        return ngx_http_output_filter(m_r, &out);
    }
};

#endif // NGX_REQUEST_HPP

这个NgxRequest类，一下子把处理HTTP请求的复杂度，从“专家模式”拉到了“新手友好模式”。

第三章：实战！用我们的包装类写一个Nginx模块

光说不练假把式。现在，我们来用上面打造的“瑞士军刀”，写一个实实在在的Nginx模块。

功能：一个简单的Echo模块，返回请求的Method和URI。

1. 模块配置结构（依然用C，但很简单）

// ngx_http_echo_module.c
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_http.h>

// 配置结构，可以放一些开关之类的，我们这个例子不需要，留空
typedef struct {
    ngx_flag_t enabled;
} ngx_http_echo_conf_t;

2. 引入我们的C++包装类，并实现Handler
在同一个.c文件中（是的，C和C++可以混编！），我们引入头文件，并用extern "C"包裹Nginx模块必需的函数。

// 在ngx_http_echo_module.c 文件顶部附近添加
#ifdef __cplusplus
extern "C" {
#endif

/* ... Nginx标准的模块声明、配置合并函数等放在这里 ... */

#ifdef __cplusplus
}
#endif

// --- 下面是C++代码部分 ---
#include "NgxRequest.hpp"
#include "NgxString.hpp"

static ngx_int_t
ngx_http_echo_handler(ngx_http_request_t *r)
{
    // 使用我们的C++包装类！
    NgxRequest req(r);

    // 1. 检查方法，只允许GET
    if (req.getMethod() != NgxString(ngx_string("GET"))) {
        return NGX_HTTP_NOT_ALLOWED;
    }

    // 2. 准备响应内容
    std::string response = "Hello from C++ Wrapper!\n";
    response += "Your Method is: " + req.getMethod().toStdString() + "\n";
    response += "Your URI is: " + req.getUri().toStdString() + "\n";

    // 3. 设置响应头
    req.setStatus(NGX_HTTP_OK);
    req.setContentType(NgxString(ngx_string("text/plain; charset=utf-8")));

    // 4. 发送响应头
    if (req.sendHeader() == NGX_ERROR) {
        return NGX_ERROR;
    }

    // 5. 发送响应体
    NgxString body(r->pool, response); // 使用内存池分配并构造NgxString
    return req.sendBody(body);
}

// 注意：Nginx的模块定义、命令表、初始化等仍然用C代码，这里省略...
// 但在命令表中，将 `ngx_http_echo_handler` 设置为这个模块的handler。

3. 编译配置 (config)
要让Nginx编译系统知道你在用C++，需要创建一个config文件。

# 这是给Nginx的`configure`脚本看的
ngx_addon_name="ngx_http_echo_module"
# 关键！告诉Nginx用C++编译器来编译这个源文件
CXX="$CXX -std=c++11" # 指定C++标准，根据你的编译器调整

HTTP_MODULES="$HTTP_MODULES ngx_http_echo_module"
NGX_ADDON_SRCS="$NGX_ADDON_SRCS $ngx_addon_dir/ngx_http_echo_module.c"