准备：调试工具POSTMAN

简介：用于调试B/S模式程序的一款产品，可以发送几乎所有类型的HTTP请求！Postman在发送网络HTTP请求方面可以说是Chrome插件类产品中的代表产品之一。

参考出处：

· 小坑：最好使用客户端版本，网页版要使用浏览器作为代理，默认强制使用SSL，导致无法访问资源。

HTTP Server关系图

HTTP Server 开发 - 图1

1. HTTP Session封装

目的：将服务器端accept生成出来的socket封装成一个session结构，是一个被动发起的连接，负责收取来自客户端的HTTP请求报文，并且给客户端回发响应报文。

HTTP Server 开发 - 图2

  • 核心接口：

    1.1 recvRequest()

    功能：接收HTTP请求报文

核心逻辑：先解析出报文头部，再解析报文实体

  1. 创建HttpRequestParser对象，获取当前所能接收的最大报文首部长度，根据这个长度创建一块缓冲区用于暂存接收到的请求报文

  2. 采取一边接收报文，一边解析报文头部的策略：

while(1)
{

  1. 尝试通过套接字Socket对象接收报文
  2. 根据实际接收到的报文长度ret，尝试调用HttpRequestParser::execute()执行报文解析动作，并且计算一个偏移量offset = 实际接收到的报文长度 - 实际解析的报文长度判断当前接收的却没有解析掉的报文是否超过最大限定值（4KB）。
  3. 判断解析是否已经全部完成：是，就执行break；否则，继续接收报文，继续解析。

}

  1. 存储报文实体内容。获取报文实体的长度大小，根据报文实体长度 和 2. 中得到的一个偏移量offset来判断一下当前的报文实体是否接收完整：
    1. 报文实体长度 > offset， 说明当前收到的报文实体不完整。设置一个循环，再一次接收客户端传输来的报文实体，直至报文实体完整。
    2. 报文实体长度 <= offset，说明当前收到的报文实体已经完整

  2. 将完整的报文实体放入HttpRequestParser::HttpRequest对象之中 ```cpp //收到HTTP请求报文 HttpRequest::ptr HttpSession::recvRequest() { HttpRequestParser::ptr parser(new HttpRequestParser); //使用某一时刻的值即可 不需要实时的值 uint64_t buff_size = HttpRequestParser::GetHttpRequestBufferSize();

    //创建一个接受请求报文的缓冲区 指定析构 std::shared_ptr buffer(new char[buff_size], {

    1.  delete[] ptr;

    });

    char *data = buffer.get(); int offset = 0;

    //一边读一遍解析 while(1) {

    1.  int ret = read(data + offset, buff_size - offset);
    2.  if(ret <= 0)
    3.  {
    4.      KIT_LOG_ERROR(g_logger) << "HttpSession::recvRequest read error, errno=" << errno
    5.          << ", is:" << strerror(errno);
    6.      return nullptr;
    7.  }
    9.  ret += offset;
    11.  size_t n = parser->execute(data, ret);
    12.  if(parser->hasError())
    13.  {   
    14.      KIT_LOG_ERROR(g_logger) << "HttpSession::recvRequest parser error";
    15.      return nullptr;
    16.  }
  1.     offset = ret - n;
  2.     if(offset == (int)buff_size)
  3.     {
  4.         KIT_LOG_WARN(g_logger) << "HttpSession::recvRequest http requestion out of buffer's range";
  5.         return nullptr;
  6.     }
  8.     //如果解析已经结束
  9.     if(parser->isFinished())
  10.         break;
  12. }
  14. //获取实体长度
  15. int64_t len = parser->getContenLength();
  16. if(len > HttpRequestParser::GetHttpMaxBodySize())
  17. {
  18.     KIT_LOG_WARN(g_logger) << "HttpSession::recvRequest body length too long!";
  19.     return nullptr;
  20. }
  22. //将报文实体读出 并且设置到HttpRequest对象中去
  23. if(len > 0)
  24. {
  25.     std::string body;
  26.     body.resize(len);
  28.     //这里offset 就是报文首部解析完之后 剩余的报文实体的字节数
  29.     if(len > offset)
  30.         body.append(data, offset);
  31.     else
  32.         body.append(data, len);
  34.     len -= offset;
  35.     //如果还有剩余的报文实体长度 说明报文实体没有在本次传输中全部被接收
  36.     //设置一个循环继续接收报文实体
  37.     while(len > 0)
  38.     {
  39.         if(readFixSize(&body[body.size()], len) <= 0)
  40.         {
  41.             KIT_LOG_ERROR(g_logger) << "HttpSession::recvRequest readFixSize error, errno=" << errno
  42.                 << ", is:" << strerror(errno);
  43.             return nullptr;
  44.         }
  45.     }
  47.     //等到报文实体完整之后 装入对象之中 
  48.     parser->getData()->setBody(body);
  49. }
  51. return parser->getData();

}

  2. <a name="GRvZz"></a>
  3. ## 1.2 `sendResponse()`
  4. 功能：传入已经组装好的报文，给客户端发送HTTP响应报文
  5. ```cpp
  6. //发回HTTP响应报文
  7. int HttpSession::sendResponse(HttpResponse::ptr rsp)
  8. {
  9.     std::stringstream ss;
  10.     ss << *rsp;
  12.     std::string data = ss.str();
  13.     return writeFixSize(data.c_str(), data.size());
  14. }

1.3 HTTP Server类封装

功能：利用已经封装好的HttpSession类，搭建一个简单的HTTP交互服务器。接收HTTP请求报文，正确解析后，给客户端回发一个简单的响应报文，封装原来的请求报文。

  1. namespace kit_server
  2. {
  3. namespace http
  4. {
  6. class HttpServer: public TcpServer
  7. {
  8. public:
  9.     typedef std::shared_ptr<HttpServer> ptr;
  11.     HttpServer(bool keepalive = false, IOManager* worker = IOManager::GetThis(), 
  12.                 IOManager* accept_worker = IOManager::GetThis());
  14.     bool getKeepalive() const {return m_isKeepalive;}
  17. protected:
  18.     //处理已经连接的客户端  完成数据交互通信
  19.     virtual void handleClient(Socket::ptr client) override;
  21. private:
  22.     //是否支持长连接
  23.     bool m_isKeepalive;
  25. };
  28. }
  29. }

  • **handleClient()**函数中负责请求和应答收发： ```cpp //处理已经连接的客户端 完成数据交互通信 void HttpServer::handleClient(Socket::ptr client) { KIT_LOG_INFO(g_logger) << “HttpServer::handleClient, client=” << *client; HttpSession::ptr session(new HttpSession(client));

    do {

    1.   // 接收请求报文
    2.   auto req = session->recvRequest();
    3.   if(!req)
    4.   {
    5.       KIT_LOG_WARN(g_logger) << "recv http request fail, errno=" << errno
    6.           << ", is:" << strerror(errno)
    7.           << ", client=" << *client;
    8.       break;
    9.   }
  1.     //回复响应报文
  2.     HttpResponse::ptr rsp(new HttpResponse(req->getVersion(), req->isClose() || !m_isKeepalive));
  4.     rsp->setBody(std::string("hello kit!"));
  6.     session->sendResponse(rsp);
  8. } while (m_isKeepalive);
  10. session->close();

}

  1. <a name="KLhN2"></a>
  2. # 3. HTTP Servlet封装
  3. 概念：Servlet是Server Applet的一个简称，直译就是服务小程序的意思。该概念常见于Java中。一般而言，B/S模型（浏览器-服务器模型），通过浏览器发送访问请求，服务器接收请求，并对这些请求作出处理。而servlet就是专门对请求作出处理的组件。
  5. <a name="fVjx1"></a>
  6. ## 2.1 类关系设计
  7. ![](https://cdn.nlark.com/yuque/0/2022/jpeg/25460685/1646639953768-c45addb4-aa35-4637-8ee4-565f55dd75c5.jpeg)
  9. <a name="zGGz6"></a>
  10. ### 2.1.1 `Servlet`类
  11. ```cpp
  12. /**
  13.  * @brief 服务类基类
  14.  */
  15. class Servlet
  16. {
  17. public:
  18.     typedef std::shared_ptr<Servlet> ptr;  
  20.     /**
  21.      * @brief 服务类构造函数
  22.      * @param[in] name 服务名称
  23.      */
  24.     Servlet(const std::string& name):m_name(name) { }
  26.     /**
  27.      * @brief 服务类析构函数
  28.      */
  29.     virtual ~Servlet() {}
  31.     /**
  32.      * @brief 执行服务（虚接口）
  33.      * @param[in] request HTTP请求报文
  34.      * @param[in] response HTTP响应报文
  35.      * @param[in] session HTTP主动连接会话
  36.      * @return int32_t 
  37.      */
  38.     virtual int32_t handle(HttpRequest::ptr request, HttpResponse::ptr response, HttpSession::ptr session) = 0;
  40.     /**
  41.      * @brief 获取服务名称
  42.      * @return const std::string& 
  43.      */
  44.     const std::string& getName() const {return m_name;}
  46. protected:
  47.     /// 服务名称
  48.     std::string m_name;
  49. };

2.1.2 FunctionServlet类

  1. /**
  2.  * @brief 函数服务类
  3.  */
  4. class FunctionServlet: public Servlet
  5. {
  6. public:
  7.     typedef std::shared_ptr<FunctionServlet> ptr;
  8.     typedef std::function<int32_t (HttpRequest::ptr request, 
  9.         HttpResponse::ptr response, HttpSession::ptr session)> callback;
  11.     /**
  12.      * @brief 函数服务类
  13.      * @param[in] cb 服务回调函数
  14.      * @param[in] name 服务名称
  15.      */
  16.     FunctionServlet(callback cb, const std::string& name = "FunctionServlet");
  18.     /**
  19.      * @brief 执行服务
  20.      * @param[in] request HTTP请求报文
  21.      * @param[in] response HTTP响应报文
  22.      * @param[in] session HTTP主动连接会话
  23.      * @return int32_t 
  24.      */
  25.     int32_t handle(HttpRequest::ptr request, HttpResponse::ptr response, HttpSession::ptr session) override;
  27. private:
  28.     /// 回调函数
  29.     callback m_cb;
  30. };

2.1.3ServletDispatch类

  • 使用unordered_map容器存储精准匹配的服务对象，不允许同一个资源有重复的处理。

  • 使用vector<pair< > >组合容器存储模糊匹配的服务对象，允许同一个资源有重复的处理。

  • 由于服务也属于一种公共资源，应考虑线程安全的问题，对服务的管理属于一种”读多写少”的场景，考虑使用读写锁。 ```cpp class ServletDispatch: public Servlet { public: typedef std::shared_ptr ptr; typedef RWMutex MutexType;

    ServletDispatch(const std::string& name = “ServletDispatch”);

    //服务执行 int32_t handle(HttpRequest::ptr request, HttpResponse::ptr response, HttpSession::ptr session) override;

    //添加服务 void addServlet(const std::string& uri, Servlet::ptr slt); void addServlet(const std::string& uri, FunctionServlet::callback cb); void addGlobServlet(const std::string& uri, Servlet::ptr slt); void addGlobServlet(const std::string& uri, FunctionServlet::callback cb);

    //删除精准匹配服务 void delServlet(const std::string& uri); //删除模糊匹配服务 void delGlobServlet(const std::string& uri);

    //获取默认服务 Servlet::ptr getDefault() const {return m_default;} //设置默认服务 void setDefault(Servlet::ptr v) {m_default = v;}

    //获取精准匹配服务对象 Servlet::ptr getServlet(const std::string& uri); //获取模糊匹配服务对象 Servlet::ptr getGlobServlet(const std::string& uri); //获取任意一个符合的服务对象 Servlet::ptr getMatchedServlet(const std::string& uri);

private: //uri—->servlet 精准匹配 temp/xxxx std::unordered_map m_datas; //uri—->servlet 模糊匹配 temp/* std::vector > m_globs; //默认Servlet 所有路径都没匹配到时使用 Servlet::ptr m_default; //读写锁 读多写少 MutexType m_mutex;

};

  2. <a name="ja5DC"></a>
  3. ## 2.2 核心接口
  4. <a name="VKHqb"></a>
  5. ### `handle()`
  6. 通过虚基类`Servlet`定义出一个接口`handle()`，负责去执行不同请求所要对应的服务。
  8. - `FunctionServlet`继承后，通过回调函数的形式，存储相应的请求所要做的处理动作，通过`handel()`去执行该回调函数。
  9. ```cpp
  10. int32_t FunctionServlet::handle(HttpRequest::ptr request, HttpResponse::ptr response, HttpSession::ptr session)
  11. {
  12.     return m_cb(request, response, session);
  13. }
  • ServletDispatch继承后，负责管理所有的服务对象，支持精准资源请求、模糊资源请求，通过handle()去执行分管的子服务的回调函数。当一个请求到达服务器端，优先精准匹配符合的请求资源，如果没有就去检索有可能符合的请求资源。都没有找到相对应的资源，将使用一个默认的服务来处理这个可能不太合法的请求。 ```cpp

//服务执行 int32_t ServletDispatch::handle(HttpRequest::ptr request, HttpResponse::ptr response, HttpSession::ptr session) { auto slt = getMatchedServlet(request->getPath()); if(slt) slt->handle(request, response, session);

  1. return 0;

} 

  3. <a name="l1mLT"></a>
  4. ## 2.3 HTTP Server类封装
  5. 功能：综合之前`HttpSession`类的功能，将`Servlet`类的功能加入，实现不同请求对应不同服务。
  7. - **添加相应的服务管理对象**`**Servlet**`
  8. ```cpp
  9. /**
  10.  * @brief HTTP服务器类
  11.  */
  12. class HttpServer: public TcpServer
  13. {
  14. public:
  15.     typedef std::shared_ptr<HttpServer> ptr;
  17.     /**
  18.      * @brief HTTP服务器类构造函数
  19.      * @param[in] keepalive 是否是长连接 默认否
  20.      * @param[in] worker 服务执行调度器 默认是当前线程持有的调度器
  21.      * @param[in] accept_worker 接收连接调度器 默认是当前线程持有的调度器
  22.      */
  23.     HttpServer(bool keepalive = false, IOManager* worker = IOManager::GetThis(), 
  24.                 IOManager* accept_worker = IOManager::GetThis());
  26.     /**
  27.      * @brief 获取长连接状态
  28.      * @return true 处于长连接
  29.      * @return false 处于短连接
  30.      */
  31.     bool getKeepalive() const {return m_isKeepalive;}
  33.     /**
  34.      * @brief 获取服务分发器
  35.      * @return ServletDispatch::ptr 
  36.      */
  37.     ServletDispatch::ptr getServletDispatch() const {return m_dispatch;}
  39.     /**
  40.      * @brief 设置服务分发器
  41.      * @param[in] v 
  42.      */
  43.     void setServletDispatch(ServletDispatch::ptr v) {m_dispatch = v;}
  45.     /**
  46.      * @brief 设置服务器名称
  47.      * @param[in] v 
  48.      */
  49.     virtual void setName(const std::string& v) override;
  51. protected:
  52.     /**
  53.      * @brief 处理已经连接的客户端  完成数据交互通信
  54.      * @param[in] client 和客户端通信的Socket对象智能指针
  55.      */
  56.     virtual void handleClient(Socket::ptr client) override;
  58. private:
  59.     /// 是否支持长连接
  60.     bool m_isKeepalive;
  61.     /// 服务分发器
  62.     ServletDispatch::ptr m_dispatch;
  63. };

  • **handleClient()**函数从原来的固定一收一答，转为根据不同请求获取不同服务，并设置相对应的响应报文。 ```cpp //处理已经连接的客户端 完成数据交互通信 void HttpServer::handleClient(Socket::ptr client) { KIT_LOG_INFO(g_logger) << “HttpServer::handleClient, client=” << *client; HttpSession::ptr session(new HttpSession(client));

    do {

    1.   // 接收请求报文
    2.   auto req = session->recvRequest();
    3.   if(!req)
    4.   {
    5.       KIT_LOG_WARN(g_logger) << "recv http request fail, errno=" << errno
    6.           << ", is:" << strerror(errno)
    7.           << ", client=" << *client;
    8.       break;
    9.   }
  1.     //回复响应报文
  2.     HttpResponse::ptr rsp(new HttpResponse(req->getVersion(), req->isClose() || !m_isKeepalive));
  4.     m_dispatch->handle(req, rsp, session);
  5.     // rsp->setBody(std::string("hello kit!"));
  7.     session->sendResponse(rsp);
  9. } while (m_isKeepalive);
  11. session->close();

}

  3. <a name="GAatT"></a>
  4. # 3. HTTP Result 结构体封装
  5. 目的：封装对远端服务器发起请求后的HTTP报文处理结果
  6. <a name="Ao3go"></a>
  7. ## 3.1 成员变量
  8. ```cpp
  9. struct HttpResult
  10. {
  11.     ....
  12.     ....
  14.     /**
  15.      * @brief 错误码枚举类型
  16.      */
  17.     enum class Error
  18.     {
  19.         //成功
  20.         OK,
  21.         //非法URL
  22.         INVALID_URL,
  23.         //非法地址
  24.         INVALID_ADDR,
  25.         //非法套接字
  26.         INVALID_SOCK,
  27.         //连接失败
  28.         CONNECT_FAIL,
  29.         //发送请求失败
  30.         SEND_REQ_FAIL,
  31.         //接收响应超时
  32.         RECV_RSP_TIMEOUT,
  33.         //连接池取出连接失败
  34.         POOL_GET_CONNECT_FAIL,
  35.         //连接池非法sokcet
  36.         POOL_INVALID_SOCK,
  38.     };
  40.     //错误码
  41.     int result;
  42.     //HTTP响应报文对象智能指针
  43.     HttpResponse::ptr response;
  44.     //错误原因短语
  45.     std::string error;
  46. };

3.2 接口

3.2.1 构造函数

  1. /**
  2.  * @brief HTTP报文处理结果结构体构造函数
  3.  * @param[in] _result 错误码
  4.  * @param[in] _response HTTP响应报文对象智能指针
  5.  * @param[in] _error 错误原因短语
  6.  */
  7. HttpResult(int _result, HttpResponse::ptr _response, const std::string& _error)
  8.     :result(_result)
  9.     ,response(_response)
  10.     ,error(_error) 
  11. {
  13. }

3.2.2 toString()

功能：HTTP报文处理结果以字符串形式输出

  1. /**
  2.  * @brief HTTP报文处理结果以字符串形式输出
  3.  * @return std::string 
  4.  */
  5. std::string toString() const;
  7. std::string HttpResult::toString() const
  8. {
  9.     std::stringstream ss;
  10.     ss << "[HttpResult result=" << result
  11.         << ", error_str=]" << error 
  12.         << ", response=\n" << (response ? response->toString() : "nullptr");
  14.     return ss.str();
  15. }

4. HTTP Connection类封装

目的：将服务器创建出来发起主动连接的socket封装成一个Connection。和之前HttpSeesion类的功能一模一样，只是此时的服务器作为一个客户端对远端另外一台服务器发起资源请求。

和**HttpSession**类接口的功能正好相反

· 类关系设计

HTTP Server 开发 - 图3

4.1 成员变量

  1. class HttpConnection
  2. {
  3.     ....
  4.     ....
  5. private:
  6.     //连接创建时间
  7.     uint64_t m_createTime;
  8.     //连接上的请求数
  9.     uint64_t m_requestCount;
  11. };


4.2 接口

4.2.1 recvResponse() （核心）

功能：接收HTTP响应报文。支持HTTP chunck发包形式。

  • 核心逻辑：先解析出报文头部，再解析报文实体

  1. 创建HttpRequestParser对象，获取当前所能接收的最大报文首部长度，根据这个长度创建一块缓冲区用于暂存接收到的请求报文

  2. 采取一边接收报文，一边解析报文头部的策略：

while(1)
{

  1. 尝试通过套接字Socket对象接收报文
  2. 根据实际接收到的报文长度ret，尝试调用HttpResponseParser::execute()执行报文解析动作，并且计算一个偏移量offset = 实际接收到的报文长度 - 实际解析的报文长度判断当前的报文是否超过最大报文首部限定值（4KB）。
  3. 判断解析是否已经全部完成：是，就执行break；否则，继续接收报文，继续解析。

}

  1. 根据解析出的报文首部，看首部字段Transfer-Encoding:chunked，对应到代码中是之前HTTP解析模块中httpclient_parser:chuncked是否被置1：是，就表明接下来的响应报文实体将以chunck形式发送；否则，就是首部报文后紧跟需要的报文实体。

    1. 报文实体是chunck形式:

do{
do{

  1.   1. 尝试接收一次`数据量=剩余缓存空间大小`的数据，尽可能的多读出报文主体
  2.   1. 调用`HttpResponseParser::execute()`进行解析。同样需要计算一个偏移量`len = 实际接收到的报文长度 - 实际解析的报文长度`判断当前的报文是否超过最大报文首部限定值（4KB）。

}while (!parser->isFinished()); //当前报文分块是否解析完成

len -= 2;
（减2非常关键 因为报文首部和实体中间还有一个空行\r\n将它算作首部的长度 不应算在body的长度中）

if(client_parser.content_len <= len){
如果当前解析包中的主体长度 <= 当前已经接受到的并且解析好的报文主体长度
说明缓冲区中当前分块的数据量较少，另一个分块的的数据量较多。将client_parser.content_len这么多的数据放入body，然后使用memmove()将缓冲区中的未填装好的数据挪到缓冲区前覆盖已经填装掉掉的数据区域
}
else（client_parser.content_len > len）{
如果当前解析包中的主体长度 > 当前已经接受到的并且解析好的报文主体长度
说明当前缓冲区中所有的数据都是当前分块的，并且还有一部分数据没有接受到，还需要等待接收。将len（当前缓冲区中所有的数据）长度的数据放入body，计算剩余待接收的数据量left，通过read直接读取缓冲区中，又放入body中。
}

} while (!client_parser.chunks_done); //所有分块是否全部接受完毕

最后将完整的报文实体放入HttpRequestParser::HttpRequest对象之中

  1. 报文实体非chunck形式：（做法就和**recvRequest()**中一样）：
    • 存储报文实体内容。获取报文实体的长度大小，根据报文实体长度 和 2. 中得到的一个偏移量offset来判断一下当前的报文实体是否接收完整：
  2. 报文实体长度 > offset， 说明当前收到的报文实体不完整。设置一个循环，再一次接收客户端传输来的报文实体，直至报文实体完整。
  3. 报文实体长度 <= offset，说明当前收到的报文实体已经完整
  • 将完整的报文实体放入HttpRequestParser::HttpRequest对象之中
  1. /**
  2.  * @brief 接收HTTP响应报文
  3.  * @return HttpResponse::ptr 
  4.  */
  5. HttpResponse::ptr recvResponse();
  7. HttpResponse::ptr HttpConnection::recvResponse()
  8. {
  9.     HttpResponseParser::ptr parser(new HttpResponseParser);
  10.     //使用某一时刻的值即可 不需要实时的值
  11.     uint64_t buff_size = HttpResponseParser::GetHttpResponseBufferSize();
  13.     //创建一个接受响应报文的缓冲区 指定析构
  14.     std::shared_ptr<char> buffer(new char[buff_size + 1], [](char *ptr){
  15.         delete[] ptr;
  16.     }); 
  18.     char *data = buffer.get();
  19.     int offset = 0;
  21.     //一边读一遍解析
  22.     while(1)
  23.     {
  24.         int ret = read(data + offset, buff_size - offset);
  25.         if(ret <= 0)
  26.         {
  27.             KIT_LOG_ERROR(g_logger) << "HttpConnection::recvResponse read error, errno=" << errno
  28.                 << ", is:" << strerror(errno);
  29.             close();
  30.             return nullptr;
  31.         }
  33.         ret += offset;
  34.         data[ret] = '\0';
  35.         size_t n = parser->execute(data, ret, false);
  37.         if(parser->hasError())
  38.         {   
  39.             KIT_LOG_ERROR(g_logger) << "HttpConnection::recvResponse parser error";
  40.             close();
  41.             return nullptr;
  42.         }
  45.         offset = ret - n;
  46.         if(offset == (int)buff_size)
  47.         {
  48.             KIT_LOG_WARN(g_logger) << "HttpConnection::recvResponse http response buffer out of  range";
  49.             close();
  50.             return nullptr;
  51.         }
  53.         //如果解析已经结束
  54.         if(parser->isFinished())
  55.             break;
  57.     }
  59.     KIT_LOG_DEBUG(g_logger) << "已经解析得到的报文:\n" << parser->getData()->toString();
  62.     auto& client_parser = parser->getParser();
  63.     //如果发送方式为chunked 分块发送 就需要分块接收
  64.     if(client_parser.chunked)
  65.     {   
  66.         std::string body;
  67.         //拿到剩余报文的长度
  68.         int len = offset;
  70.         do
  71.         {
  73.             // KIT_LOG_DEBUG(g_logger) << "报文正在 chuncked!!!!!!"; 
  74.             do
  75.             {
  76.                 //尝试读取一次 剩余的缓存空间大小的数据 尽可能的多读出主体
  77.                 int ret = read(data + len, buff_size - len);
  78.                 if(ret <= 0)
  79.                 {
  80.                     KIT_LOG_ERROR(g_logger) << "HttpConnection::recvResponse read error, errno=" << errno
  81.                         << ", is:" << strerror(errno);
  82.                     close();
  83.                     return nullptr;
  84.                 }
  87.                 len += ret;
  88.                 data[len] = '\0';
  90.                 //开启分块解析
  91.                 size_t n = parser->execute(data, len, true);
  92.                 if(parser->hasError())
  93.                 {   
  94.                     KIT_LOG_ERROR(g_logger) << "HttpConnection::recvResponse parser error";
  95.                     close();
  96.                     return nullptr;
  97.                 }
  99.                 len -= n;
  100.                 if(len == (int)buff_size)   //读了数据但是没有解析  直到自己定义的缓存已经满了
  101.                 {
  102.                     KIT_LOG_WARN(g_logger) << "HttpConnection::recvResponse http response buffer out of  range";
  103.                     close();
  104.                     return nullptr;
  105.                 }
  108.             } while (!parser->isFinished());     //当前分块是否已经解析完毕
  110.             /*这个减2非常关键 因为报文首部和实体中间还有一个空行\r\n将它算作首部的长度 不应算在body的长度中*/
  111.             len -= 2;
  114.             //如果当前解析包中的主体长度小于 当前已经接受到的并且解析好的报文主体长度
  115.             if(client_parser.content_len <= len)
  116.             {
  117.                 body.append(data, client_parser.content_len);
  118.                 //将已经装入的部分的内存 移动覆盖前面的内存
  119.                 memmove(data, data + client_parser.content_len, len - client_parser.content_len);
  120.                 len -= client_parser.content_len;
  121.             }
  122.             else    //否则当前解析包中的主体长度 大于 当前接收到的并且解析好的报文主体长度
  123.             {
  124.                 body.append(data, len);
  126.                 //计算还有多少报文主体未接收到
  127.                 int left = client_parser.content_len - len;
  129.                 while(left > 0)
  130.                 {
  131.                     //继续接收剩余的报文主体
  132.                     int ret = read(data, left > (int)buff_size ? (int)buff_size : left);
  133.                     if(ret <= 0)
  134.                     {
  135.                         KIT_LOG_ERROR(g_logger) << "HttpConnection::recvResponse read error, errno=" << errno
  136.                             << ", is:" << strerror(errno);
  137.                         close();
  138.                         return nullptr;
  139.                     }
  141.                     body.append(data, ret);
  142.                     left -= ret;
  143.                 }
  145.                 len = 0;
  146.             }
  148.         } while (!client_parser.chunks_done);   //所有分块是否全部接受完毕
  150.         parser->getData()->setBody(body);
  151.     }
  152.     else
  153.     {
  154.         //获取实体长度
  155.         int64_t len = parser->getContenLength();
  157.         //将报文实体读出 并且设置到HttpRequest对象中去
  158.         if(len > 0)
  159.         {
  160.             std::string body;
  161.             body.resize(len);
  163.             int real_len = 0;
  165.             //这里offset 就是报文首部解析完之后 剩余的报文实体的字节数
  166.             if(len >= offset)
  167.             {
  168.                 memcpy(&body[0], data, offset);
  169.                 //body.append(data, offset);
  170.                 real_len = offset;
  171.             }
  172.             else
  173.             {
  174.                 memcpy(&body[0], data, len);
  175.                 // body.append(data, len);
  176.                 real_len = len;
  178.             }
  181.             len -= offset;
  182.             //如果还有剩余的报文实体长度 说明报文实体没有在本次传输中全部被接收
  183.             //设置一个循环继续接收报文实体
  184.             if(len > 0)
  185.             {
  186.                 if(readFixSize(&body[real_len], real_len) <= 0)
  187.                 {
  188.                     KIT_LOG_ERROR(g_logger) << "HttpConnection::recvResponse readFixSize error, errno=" << errno
  189.                         << ", is:" << strerror(errno);
  190.                     close();
  191.                     return nullptr;
  192.                 }
  193.             }
  195.             //等到报文实体完整之后 装入对象之中 
  196.             parser->getData()->setBody(body);
  197.         }
  198.     }
  200.     return parser->getData();
  201. }

4.2.2 sendRequest()

功能：传入已经组装好的报文，给远端服务器发送HTTP请求报文

  1. //发送HTTP请求报文
  2. int HttpConnection::sendRequest(HttpRequest::ptr rsp)
  3. {
  4.     std::stringstream ss;
  5.     ss << *rsp;
  7.     std::string data = ss.str();
  8.     return writeFixSize(data.c_str(), data.size());
  9. }


4.2.3 常用接口

  1. /**
  2.  * @brief 设置连接创建时间
  3.  * @param[in] v 具体创建时间 单位ms
  4.  */
  5. void setCreateTime(uint64_t v) {m_createTime = v;}
  7. /**
  8.  * @brief 获取连接创建时间
  9.  * @return uint64_t 单位ms
  10.  */
  11. uint64_t getCreateTime() const {return m_createTime;}
  13. /**
  14.  * @brief HTTP连接上请求数+1
  15.  */
  16. void addRequestCount() {++m_requestCount;}
  18. /**
  19.  * @brief 获取HTTP连接上请求数
  20.  * @return uint64_t 
  21.  */
  22. uint64_t getRequestCount() const {return m_requestCount;}


4.2.4 发起HTTP请求系列函数

4.2.4.1 DoRequest(HttpRequest::ptr req, Uri::ptr uri, uint64_t timeout_ms)

功能：负责将HTTP请求发给目标服务器。有多个以此函数为基础，扩展出来的重载函数/便捷接口

  1. /**
  2.  * @brief 负责将HTTP请求发给目标服务器
  3.  * @param[in] req 指定的HTTP请求智能指针
  4.  * @param[in] uri 指定的URI智能指针
  5.  * @param[in] timeout_ms 接收超时时间 单位ms
  6.  * @return HttpResult::ptr 
  7.  */
  8. static HttpResult::ptr DoRequest(HttpRequest::ptr req, Uri::ptr uri, uint64_t timeout_ms);
  10. HttpResult::ptr HttpConnection::DoRequest(HttpRequest::ptr req, Uri::ptr uri, uint64_t timeout_ms)
  11. {
  12.     //通过URI对象智能指针创建地址对象
  13.     Address::ptr addr = uri->createAddress();
  14.     KIT_LOG_DEBUG(g_logger) << "DoRequest addr=" << *addr;
  15.     if(!addr)
  16.     {
  17.         KIT_LOG_ERROR(g_logger) << "HttpConnection::DoRequest get addr fail";
  18.         return std::make_shared<HttpResult>((int)HttpResult::Error::INVALID_ADDR, nullptr, "invalid addr=" + uri->getHost());
  19.     }
  21.     //通过地址对象创建套接字对象
  22.     Socket::ptr sock = Socket::CreateTCP(addr);
  23.     if(!sock)
  24.     {
  25.         KIT_LOG_ERROR(g_logger) << "HttpConnection::DoRequest create socket fail";
  26.         return std::make_shared<HttpResult>((int)HttpResult::Error::INVALID_SOCK, nullptr, "invalid sock addr=" + addr->toString());
  27.     }
  29.     //通过套接字连接目标服务器
  30.     if(!sock->connect(addr))
  31.     {
  32.         KIT_LOG_ERROR(g_logger) << "HttpConnection::DoRequest socket connect fail";
  33.         return std::make_shared<HttpResult>((int)HttpResult::Error::CONNECT_FAIL, nullptr, "invalid sock addr=" + addr->toString());
  34.     }
  35.     //为套接字设置接收超时时间
  36.     sock->setRecvTimeout(timeout_ms);
  38.     //通过连接成功的套接字创建HTTP连接
  39.     HttpConnection::ptr con = std::make_shared<HttpConnection>(sock);
  41.     //通过连接发送HTTP请求报文
  42.     int ret = con->sendRequest(req);
  43.     if(ret < 0)
  44.     {
  45.         KIT_LOG_ERROR(g_logger) << "HttpConnection::DoRequest write fail, errno=" << errno
  46.             << ", is:" << strerror(errno);
  48.         return std::make_shared<HttpResult>((int)HttpResult::Error::SEND_REQ_FAIL, nullptr, "send request fail, addr=" + addr->toString() + ", errno=" + std::to_string(errno) + ",is:" + std::string(strerror(errno)));
  49.     }
  51.     //通过连接接收HTTP请求报文
  52.     auto rsp = con->recvResponse();
  53.     if(!rsp)
  54.     {
  55.         KIT_LOG_WARN(g_logger) << "HttpConnection::DoRequest recv response maybe timeout";
  57.         return std::make_shared<HttpResult>((int)HttpResult::Error::RECV_RSP_TIMEOUT, nullptr, "recv response maybe timeout, addr=" + addr->toString() + ", timeout=" + std::to_string(timeout_ms));
  58.     }
  60.     //返回HTTP处理结果的结构体指针指针
  61.     return std::make_shared<HttpResult>((int)HttpResult::Error::OK, rsp, "OK");
  62. }

4.2.4.2 重载/便捷接口

  1. /**
  2.  * @brief 用GET方法将HTTP请求发给目标服务器
  3.  * @param[in] url 指定访问的网址
  4.  * @param[in] timeout_ms 接收超时时间 单位ms
  5.  * @param[in] headers 指定的首部字段组
  6.  * @param[in] body 指定的报文主体内容
  7.  * @return HttpResult::ptr 
  8.  */
  9. static HttpResult::ptr DoGet(const std::string& url, uint64_t timeout_ms, 
  10.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  12. /**
  13.  * @brief 用POST方法将HTTP请求发给目标服务器
  14.  * @param[in] url 指定访问的网址
  15.  * @param[in] timeout_ms 接收超时时间 单位ms
  16.  * @param[in] headers 指定的首部字段组
  17.  * @param[in] body 指定的报文主体内容
  18.  * @return HttpResult::ptr 
  19.  */
  20. static HttpResult::ptr DoPost(const std::string& url, uint64_t timeout_ms, 
  21.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  23. /**
  24.  * @brief 用GET方法将HTTP请求发给目标服务器
  25.  * @param[in] uri 指定URI对象智能指针
  26.  * @param[in] timeout_ms 接收超时时间 单位ms
  27.  * @param[in] headers 指定的首部字段组
  28.  * @param[in] body 指定的报文主体内容
  29.  * @return HttpResult::ptr 
  30.  */
  31. static HttpResult::ptr DoGet(Uri::ptr uri, uint64_t timeout_ms, 
  32.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  34. /**
  35.  * @brief 用POST方法将HTTP请求发给目标服务器
  36.  * @param[in] uri 指定URI对象智能指针
  37.  * @param[in] timeout_ms 接收超时时间 单位ms
  38.  * @param[in] headers 指定的首部字段组
  39.  * @param[in] body 指定的报文主体内容
  40.  * @return HttpResult::ptr 
  41.  */
  42. static HttpResult::ptr DoPost(Uri::ptr uri, uint64_t timeout_ms,
  43.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  45. /**
  46.  * @brief 负责将HTTP请求发给目标服务器
  47.  * @param[in] method HTTP请求方法
  48.  * @param[in] url 指定访问的网址
  49.  * @param[in] timeout_ms 接收超时时间 单位ms
  50.  * @param[in] headers 指定的首部字段组
  51.  * @param[in] body 指定的报文主体内容
  52.  * @return HttpResult::ptr 
  53.  */
  54. static HttpResult::ptr DoRequest(HttpMethod method, const std::string& url, uint64_t timeout_ms, 
  55.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  58. /**
  59.  * @brief 负责将HTTP请求发给目标服务器
  60.  * @param[in] method HTTP请求方法
  61.  * @param[in] uri 指定URI对象智能指针
  62.  * @param[in] timeout_ms 接收超时时间 单位ms
  63.  * @param[in] headers 指定的首部字段组
  64.  * @param[in] body 指定的报文主体内容
  65.  * @return HttpResult::ptr 
  66.  */
  67. static HttpResult::ptr DoRequest(HttpMethod method, Uri::ptr uri, uint64_t timeout_ms, 
  68.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  1. HttpResult::ptr HttpConnection::DoGet(const std::string& url, 
  2.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  3. {
  4.     //通过字符串解析并创建URI对象
  5.     Uri::ptr uri = Uri::Create(url);
  6.     if(!uri)
  7.     {
  8.         KIT_LOG_ERROR(g_logger) << "HttpConnection::DoGet Uri parser error";
  9.         return std::make_shared<HttpResult>((int)HttpResult::Error::INVALID_URL, nullptr, "invalid url: " + url);
  10.     }
  12.     return DoGet(uri, timeout_ms, headers, body);
  14. }
  17. HttpResult::ptr HttpConnection::DoPost(const std::string& url, 
  18.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  19. {
  20.     //通过字符串解析并创建URI对象
  21.     Uri::ptr uri = Uri::Create(url);
  22.     if(!uri)
  23.     {
  24.         KIT_LOG_ERROR(g_logger) << "HttpConnection::DoPost Uri parser error";
  25.         return std::make_shared<HttpResult>((int)HttpResult::Error::INVALID_URL, nullptr, "invalid url: " + url);
  26.     }
  28.     return DoPost(uri, timeout_ms, headers, body);
  29. }
  32. HttpResult::ptr HttpConnection::DoGet(Uri::ptr uri, 
  33.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  34. {
  35.     return DoRequest(HttpMethod::GET, uri, timeout_ms, headers, body);
  36. }
  39. HttpResult::ptr HttpConnection::DoPost(Uri::ptr uri, 
  40.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  41. {
  42.     return DoRequest(HttpMethod::POST, uri, timeout_ms, headers, body);
  43. }
  46. HttpResult::ptr HttpConnection::DoRequest(HttpMethod method, const std::string& url, 
  47.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  48. {
  49.     //通过字符串解析并创建URI对象
  50.     Uri::ptr uri = Uri::Create(url);
  51.     if(!uri)
  52.     {
  53.         KIT_LOG_ERROR(g_logger) << "HttpConnection::DoRequest Uri parser error";
  54.         return std::make_shared<HttpResult>((int)HttpResult::Error::INVALID_URL, nullptr, "invalid url: " + url);
  55.     }
  57.     return DoRequest(method, uri, timeout_ms, headers, body);
  59. }
  62. HttpResult::ptr HttpConnection::DoRequest(HttpMethod method, Uri::ptr uri, 
  63.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  64. {
  65.     /*组装HTTP请求报文*/
  66.     HttpRequest::ptr req = std::make_shared<HttpRequest>();
  67.     req->setMethod(method);                 //设置请求方法
  68.     req->setPath(uri->getPath());           //设置请求资源路径  
  69.     req->setQuery(uri->getQuery());         //设置查询参数
  70.     req->setFragment(uri->getFragment());   //设置分段标识符
  71.     bool has_host = false;
  72.     for(auto &x : headers)
  73.     {
  74.         if(strcasecmp(x.first.c_str(), "connection") == 0 && 
  75.             strcasecmp(x.second.c_str(), "keep-alive") == 0)
  76.         {
  77.                 req->setClose(false);
  78.         }
  80.         if(has_host && strcasecmp(x.first.c_str(), "host") == 0)
  81.             has_host = !x.second.empty();
  83.         req->setHeader(x.first, x.second);
  84.     }
  85.     if(!has_host)
  86.         req->setHeader("host", uri->getHost());
  88.     req->setBody(body);
  90.     return DoRequest(req, uri, timeout_ms);
  91. }

紧急：需要理解ragel的语法规则、正则表达式规则

5. URI 封装

参考出处：RFC 3986 文档
https://www.ietf.org/rfc/rfc3986

ragel官方文档：
http://www.colm.net/files/ragel/ragel-guide-6.10.pdf

  • uri官方标准格式规范：

image.png

5.1 成员变量

  1. class Uri
  2. {
  3.     ...
  4.     ...
  5. private:
  6.     //scheme字段
  7.     std::string m_scheme;
  8.     //用户认证信息字段
  9.     std::string m_userinfo;
  10.     //域名字段
  11.     std::string m_host;
  12.     //端口号字段
  13.     int16_t m_port;
  14.     //资源路径字段
  15.     std::string m_path;
  16.     //查询参数字段
  17.     std::string m_query;
  18.     //片段标识符字段
  19.     std::string m_fragment;
  20. };

5.2 ragel文件编写uri.rl

功能：ragel状态机以及URI类的实现都放在这个文件中

通过ragel -C -G2 uri.rl -o uri.rl.cpp最终生成我们所需的.cpp文件，会在调用状态机的地方自动生成C/C++的代码嵌入到源代码中。

  1. /*
  2. see RFC 3986: 
  3. Appendix A.  Collected ABNF for URI
  5.   URI           = scheme ":" hier-part [ "?" query ] [ "" fragment ]
  7.    hier-part     = "//" authority path-abempty
  8.                  / path-absolute
  9.                  / path-rootless
  10.                  / path-empty
  12.    URI-reference = URI / relative-ref
  14.    absolute-URI  = scheme ":" hier-part [ "?" query ]
  16.    relative-ref  = relative-part [ "?" query ] [ "" fragment ]
  18.    relative-part = "//" authority path-abempty
  19.                  / path-absolute
  20.                  / path-noscheme
  21.                  / path-empty
  23.    scheme        = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
  25.    authority     = [ userinfo "@" ] host [ ":" port ]
  26.    userinfo      = *( unreserved / pct-encoded / sub-delims / ":" )
  27.    host          = IP-literal / IPv4address / reg-name
  28.    port          = *DIGIT
  30.    IP-literal    = "[" ( IPv6address / IPvFuture  ) "]"
  32.    IPvFuture     = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
  34.    IPv6address   =                            6( h16 ":" ) ls32
  35.                  /                       "::" 5( h16 ":" ) ls32
  36.                  / [               h16 ] "::" 4( h16 ":" ) ls32
  37.                  / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
  38.                  / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
  39.                  / [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
  40.                  / [ *4( h16 ":" ) h16 ] "::"              ls32
  41.                  / [ *5( h16 ":" ) h16 ] "::"              h16
  42.                  / [ *6( h16 ":" ) h16 ] "::"
  44.    h16           = 1*4HEXDIG
  45.    ls32          = ( h16 ":" h16 ) / IPv4address
  46.    IPv4address   = dec-octet "." dec-octet "." dec-octet "." dec-octet */
  49. #include <string>
  50. #include <sstream>
  51. #include <iostream>
  53. #include "uri.h"
  55. namespace kit_server
  56. {
  58. /* machine */
  60. %%{
  61.     machine uri_parser;
  63.     sub_delims    = ( "!" | "$" | "$" | "&" | "'" | "(" | ")" | "*"
  64.                     | "+" | "," | ";" | "=") ;
  65.     gen_delims    = ( ":" | "/" | "?" | "#" | "[" | "]" | "@" ) ;
  66.     reserved      = ( gen_delims | sub_delims ) ;
  67.     unreserved    = ( alpha | digit | "-" | "." | "_" | "~" ) ;
  68.     pct_encoded   = ( "%" xdigit xdigit ) ;
  70.     action marku { mark = fpc; }
  71.     action markh { mark = fpc; }
  73.     action save_scheme
  74.     {
  75.         uri->setScheme(std::string(mark, fpc - mark));
  76.         mark = NULL;
  77.     }
  79.     scheme = (alpha (alpha | digit | "+" | "-" | ".")*) >marku %save_scheme;
  82.     action save_port
  83.     {
  84.         if(fpc != mark){
  85.             uri->setPort(atoi(mark));
  86.         }
  87.         mark = NULL;
  88.     }
  90.     action save_userinfo
  91.     {
  92.         if(mark) {
  93.             uri->setUserinfo(std::string(mark, fpc - mark));
  94.         }
  95.         mark = NULL;
  96.     }
  98.     action save_host
  99.     {
  100.         if(mark != NULL) {
  101.             uri->setHost(std::string(mark, fpc - mark));
  102.         }
  103.     }
  105.     userinfo = (unreserved | pct_encoded | sub_delims | ":")*;
  106.     dec_octet = digit | [1-9] digit | "l" digit{2} | 2 [0-4] digit | "25" [0-5];
  107.     IPv4address = dec_octet "." dec_octet "." dec_octet "." dec_octet;
  108.     h16 = xdigit{1,4};
  109.     ls32 = (h16 : h16) | IPv4address;
  110.     IPv6address = (                            ( h16 ":" ) {6} ls32) |
  111.                   (                       "::" ( h16 ":" ) {5} ls32) |
  112.                   ((               h16 )? "::" ( h16 ":" ) {4} ls32) |
  113.                   ((( h16 ":" ){1} h16 )? "::" ( h16 ":" ) {3} ls32) |
  114.                   ((( h16 ":" ){2} h16 )? "::" ( h16 ":" ) {2} ls32) |
  115.                   ((( h16 ":" ){3} h16 )? "::" ( h16 ":" ) {1} ls32) |
  116.                   ((( h16 ":" ){4} h16 )? "::"                 ls32) |
  117.                   ((( h16 ":" ){5} h16 )? "::"                 h16 ) |
  118.                   ((( h16 ":" ){6} h16 )? "::"                     );
  119.     IPvFuture = "v" xdigit+ "." (unreserved | sub_delims | ":")+;
  120.     IP_literal = "[" (IPv6address | IPvFuture) "]";
  121.     reg_name = (unreserved | pct_encoded | sub_delims)*;
  122.     host = IP_literal | IPv4address | reg_name;
  123.     port = digit*;
  125.     authority = ( (userinfo %save_userinfo "@")? host >markh %save_host (":" port >markh %save_port)? ) >markh;
  127.     action save_segment
  128.     {
  129.         uri->setFragment(std;:String(mark, fpc - mark));
  130.         mark = NULL;
  131.     }
  133.     action save_path
  134.     {
  135.         uri->setPath(std::string(mark, fpc - mark));
  136.         mark = NULL;
  137.     }
  139. #    pchar = unreserved | pct_encoded | sub_delims | ":" | "@";
  140. # add (any -- ascii) support chinese
  142.     pchar = ( (any -- ascii) ) | unreserved | pct_encoded | sub_delims | ":" | "@";
  143.     segment = pchar*;
  144.     segment_nz = pchar+;
  145.     segment_nz_nc = (pchar - ":")+;
  147.     action clear_segments
  148.     {  
  149.     }
  151.     path_abempty = (("/" segment))? ("/" segment)*;
  152.     path_absolute = ("/" (segment_nz ("/" segment)*)?);
  153.     path_noscheme = segment_nz_nc ("/" segment)*;
  154.     path_rootless = segment_nz ("/" segment)*;
  155.     path_empty = "";
  156.     path = (path_abempty | path_absolute | path_noscheme | path_rootless | path_empty);
  159.     action save_query
  160.     {
  161.         uri->setQuery(std::string(mark, fpc - mark));
  162.         mark = NULL;
  163.     }
  165.     action save_fragment
  166.     {
  167.         uri->setFragment(std::string(mark, fpc - mark));
  168.         mark = NULL;
  169.     }
  171.     query = (pchar | "/" | "?")* >marku %save_query;
  172.     fragment = (pchar | "/" | "?")* >marku %save_fragment;
  174.     hier_part = ("//" authority path_abempty> markh %save_path) | path_absolute | path_rootless | path_empty;
  176.     relative_part = ("//" authority path_abempty) | path_absolute | path_noscheme | path_empty;
  177.     relative_ref = relative_part ("?" query)? ("#" fragment)?;
  179.     absolute_URI = scheme "?" hier_part ("?" query)?;
  181.     # Obsolete, but referenced from HTTP, so we translate
  182.     relative_URI = relative_part ("?" query)?;
  184.     URI = scheme "?" hier_part ("?" query)? ("#" fragment)?;
  185.     URI_reference = URI | relative_ref;
  186.     # 状态机入口
  187.     main := URI_reference;
  189.     write data;
  190. }%%
  192. /* exec */
  194. Uri::Uri()
  195.     :m_port(0)
  196. {
  198. }
  201. std::ostream& Uri::dump(std::ostream& os)
  202. {
  203.     os << m_scheme << "://"
  204.         << m_userinfo
  205.         << (m_userinfo.size() ? "@" : "")
  206.         << m_host
  207.         << (isDefaultPort() ? "" : ":" + std::string("" + m_port))
  208.         << "/"
  209.         << m_path
  210.         << (m_query.size() ? "?" : "")
  211.         << m_query
  212.         << (m_fragment.size() ? "#" : "")
  213.         << m_fragment;
  215.     return os;  
  216. }
  218. std::string Uri::toString()
  219. {
  220.     std::stringstream ss;
  221.     dump(ss);
  222.     return ss.str();
  223. }
  225. //通过URI创建一个地址 
  226. Address::ptr Uri::createAddress() const
  227. {
  228.     auto addr = Address::LookUpAnyIPAddress(m_host);
  229.     if(addr)
  230.         addr->setPort(m_port);
  232.     return addr;
  233. }
  235. //传入一个uri字符串解析出对应URI对象
  236. Uri::ptr Uri::Create(const std::string& u)
  237. {
  238.     Uri::ptr uri(new Uri);
  240.     int cs = 0;
  241.     const char* mark = nullptr;
  243.     //初始化状态机所需的变量
  244.     %% write init;
  245.     //头指针
  246.     const char *p = u.c_str();
  247.     //尾指针
  248.     const char *pe = p + u.size();
  249.     //ragel指定尾指针的名字
  250.     const char *eof = pe;
  251.     //开始调用 自动状态机
  252.     %% write exec;
  254.     if(cs == uri_parser_error)
  255.         return nullptr;
  256.     else if(cs >= uri_parser_first_final)
  257.         return uri;
  259.     return nullptr;
  261. }
  264. bool Uri::isDefaultPort()
  265. {
  266.     if(m_port == 0)
  267.         return true;
  269.     if(m_scheme == "http")
  270.         m_port = 80;
  271.     else if(m_scheme == "https")
  272.         m_port = 443;
  274.     return false;
  275. }
  279. }


5.3 接口

5.3.1 Create()（核心）

功能：通过字符串URI解析并创建出URI对象

  1. /**
  2.  * @brief 通过字符串URI创建URI对象
  3.  * @param[in] uri URI字符串 
  4.  * @return Uri::ptr 
  5.  */
  6. static Uri::ptr Create(const std::string& uri);
  8. Uri::ptr Uri::Create(const std::string& u)
  9. {
  10.     Uri::ptr uri(new Uri);
  12.     /*cs mark状态机中用到的变量 提前定义*/
  13.     int cs = 0;
  14.     const char* mark = NULL;
  16.     //初始化自动状态机
  17.     %% write init;
  18.     //指向u头指针
  19.     const char *p = u.c_str();
  20.     //指向u尾指针
  21.     const char *pe = p + u.size();
  22.     //ragel指定的一个尾指针的名字
  23.     const char *eof = pe;
  24.     //调用自动状态机
  25.     %% write exec;
  27.     //uri_parser_error 检查解析是否错误
  28.     if(cs == uri_parser_error)
  29.         return nullptr;
  30.     else if(cs >= uri_parser_first_final) //解析完成后的状态码是否合法  
  31.         return uri;
  33.     return nullptr;
  35. }


5.3.2 CreateAddress()

功能：通过URI中的域名创建通信地址对象

  1. /**
  2.  * @brief 通过URI中的域名创建通信地址对象
  3.  * @return Address::ptr 
  4.  */
  5. Address::ptr createAddress() const;
  7. Address::ptr Uri::createAddress() const
  8. {
  9.     auto addr = Address::LookUpAnyIPAddress(m_host);
  10.     if(addr)
  11.         addr->setPort(getPort());
  13.     return addr;
  14. }


5.3.3 dump()

功能：将URI信息以流的形式组装

  1. /**
  2.  * @brief 将URI信息以流的形式组装
  3.  * @param[in] os 标准输出流 
  4.  * @return std::ostream& 
  5.  */
  6. std::ostream& dump(std::ostream& os) const;
  8. std::ostream& Uri::dump(std::ostream& os) const
  9. {
  10.     os << m_scheme << "://"
  11.         << m_userinfo
  12.         << (m_userinfo.size() ? "@" : "")
  13.         << m_host
  14.         << (isDefaultPort() ? "" : ":" + std::string("" + m_port))
  15.         << getPath()
  16.         << (m_query.size() ? "?" : "")
  17.         << m_query
  18.         << (m_fragment.size() ? "#" : "")
  19.         << m_fragment;
  21.     return os;  
  22. }

5.3.4 toString()

功能：将URI信息以字符串形式输出

  2. /**
  3.  * @brief 将URI信息以字符串形式输出
  4.  * @return std::string 
  5.  */
  6. std::string toString() const;
  8. std::string Uri::toString() const
  9. {
  10.     std::stringstream ss;
  11.     dump(ss);
  12.     return ss.str();
  13. }

5.3.5 常用接口

  2. /**
  3.  * @brief 设置scheme字段
  4.  * @param[in] v 具体scheme值 http https ftp等
  5.  */
  6. void setScheme(const std::string& v) {m_scheme = v;}
  8. /**
  9.  * @brief 获取scheme字段
  10.  * @return const std::string& 
  11.  */
  12. const std::string& getScheme() const {return m_scheme;}
  14. /**
  15.  * @brief 设置用户认证信息
  16.  * @param[in] v  具体的用户认证信息值
  17.  */
  18. void setUserinfo(const std::string& v) {m_userinfo = v;}
  20. /**
  21.  * @brief 获取用户认证信息
  22.  * @return const std::string& 
  23.  */
  24. const std::string& getUserinfo() const {return m_userinfo;}
  26. /**
  27.  * @brief 设置域名
  28.  * @param[in] v 具体域名值  www.xxxx.com
  29.  */
  30. void setHost(const std::string& v) {m_host = v;}
  32. /**
  33.  * @brief 获取域名
  34.  * @return const std::string& 
  35.  */
  36. const std::string& getHost() const {return m_host;}
  38. /**
  39.  * @brief 设置端口号
  40.  * @param[in] v 具体端口号 
  41.  */
  42. void setPort(int16_t v) {m_port = v;}
  44. /**
  45.  * @brief 获取端口号 没有设置则根据scheme来设置http = 80 https = 443
  46.  * @return int16_t 
  47.  */
  48. int16_t getPort() const;
  49. int16_t Uri::getPort() const
  50. {
  51.     if(m_port)
  52.         return m_port;
  54.     if(m_scheme == "http")
  55.         return 80;
  56.     else if(m_scheme == "https")
  57.         return 443;
  59.     return 0;
  60. }
  62. /**
  63.  * @brief 设置资源路径
  64.  * @param[in] v 具体资源路径 
  65.  */
  66. void setPath(const std::string& v) {m_path = v;}
  68. /**
  69.  * @brief 获取资源路径 
  70.  * @return const std::string& 
  71.  */
  72. const std::string& getPath() const;
  73. const std::string& Uri::getPath() const
  74. {
  75.     static std::string temp = "/";
  76.     return m_path.size() ? m_path : temp;
  77. }
  79. /**
  80.  * @brief 设置查询参数
  81.  * @param[in] v 具体查询参数  "?query"
  82.  */
  83. void setQuery(const std::string& v) {m_query = v;}
  85. /**
  86.  * @brief 获取查询参数
  87.  * @return const std::string& 
  88.  */
  89. const std::string& getQuery() const {return m_query;}
  91. /**
  92.  * @brief 设置片段标识符
  93.  * @param[in] v 具体片段标识符的值
  94.  */
  95. void setFragment(const std::string& v) {m_fragment = v;}
  97. /**
  98.  * @brief 获取片段标识符
  99.  * @return const std::string& 
  100.  */
  101. const std::string& getFragment() const {return m_fragment;}

6. HttpConnectionPool 连接池封装

目的：利用”池化”技术将连接资源做一个统一管理，尤其对于”长连接”来讲，关注一个连接上的最大存活时间、最多能够处理的请求数量等，还要兼顾连接上的安全问题，规避一部分的攻击。并且，一个”池子”服务一个网址+一个端口，对于一个网址资源的请求连接数会很多。

· 类关系设计

HTTP Server 开发 - 图5

6.1 成员变量

  1. class HttpconnectionPool
  2. {
  3.     ....
  4.     ....
  5. private:
  6.     //要连接的主机域名
  7.     std::string m_host;
  8.     std::string m_vhost;
  9.     //端口号
  10.     uint16_t m_port;
  11.     //最大连接数
  12.     uint32_t m_maxSize;
  13.     //每条连接最大存活时间
  14.     uint32_t m_maxAliveTime;
  15.     //每条连接上最大请求数量
  16.     uint32_t m_maxRequest;
  17.     //互斥锁 读写频次相当 不用读写锁
  18.     MutexType m_mutex;
  19.     //连接存储容器  list增删方便
  20.     std::list<HttpConnection* > m_connections;
  21.     //当前连接数量 可以突破最大连接数 但是使用完毕放回后若超限就要马上释放
  22.     std::atomic<int32_t> m_tatol = {0};
  24. };

6.2 接口

6.2.1 构造函数

  1. /**
  2.  * @brief HTTP连接池类构造函数
  3.  * @param[in] host 域名
  4.  * @param[in] vhost 备用域名
  5.  * @param[in] port 端口号
  6.  * @param[in] max_size 最大连接数
  7.  * @param[in] maxAliveTime 每条连接最大存活时间
  8.  * @param[in] maxRequest 每条连接最大请求数
  9.  */
  10. HttpConnectionPool(const std::string& host, const std::string& vhost, 
  11.     uint16_t port, uint32_t max_size, uint32_t maxAliveTime, uint32_t maxRequest);
  13. HttpConnectionPool::HttpConnectionPool(const std::string& host, const std::string& vhost, 
  14.     uint16_t port, uint32_t max_size, uint32_t maxAliveTime, uint32_t maxRequest)
  15.         :m_host(host)
  16.         ,m_vhost(vhost)
  17.         ,m_port(port)
  18.         ,m_maxSize(max_size)
  19.         ,m_maxAliveTime(maxAliveTime)
  20.         ,m_maxRequest(maxRequest)
  21. {
  23. }

** 私有接口

1). ReleasePtr()

功能：释放连接资源。第二个参数HttpConnectionPool*非常关键，因为该函数静态函数static，被指定为HttpConnection对象的析构函数，只能通过传参第二个参数去判断HTTP连接池中的一些状态去决定是否释放连接资源。

  1. /**
  2.  * @brief 释放连接资源
  3.  * @param[in] ptr http连接指针
  4.  * @param[in] pool http连接池指针
  5.  */
  6. static void ReleasePtr(HttpConnection* ptr, HttpConnectionPool* pool);
  8. void HttpConnectionPool::ReleasePtr(HttpConnection* ptr, HttpConnectionPool* pool)
  9. {
  10.     //连接上的请求数+1
  11.     ptr->addRequest();
  12.     //判断当前连接是否过期:是否处于连接 || 是否超过存活时间 || 是否超出最大请求数 || 是否超出最大连接数
  13.     if(!ptr->isConnected() || 
  14.         (ptr->getCreateTime() + pool->m_maxAliveTime >= GetCurrentMs()) ||
  15.         (ptr->getRequest() > pool->m_maxRequest) || 
  16.         (pool->m_total > pool->m_maxSize))
  17.     {
  18.         delete ptr;
  19.         --pool->m_total;
  20.         return;
  21.     }
  23.     //连接未过期 把用完的连接放回连接池
  24.     MutexType::Lock lock(pool->m_mutex);
  25.     pool->m_connections.push_back(ptr);
  26. }

6.2.2 getConnection()（核心）

功能：从连接池中获取连接，同时检查连接池中的连接是否已经过期，将过期连接收集并释放资源；如果没有可用连接，新创建一条连接提供使用。

  1. /**
  2.  * @brief 从连接池中获取连接，没有可用资源要创建后返回
  3.  * @return HttpConnection::ptr 
  4.  */
  5. HttpConnection::ptr getConnection();
  7. HttpConnection::ptr HttpConnectionPool::getConnection()
  8. {
  9.     //收集过期连接vector容器
  10.     std::vector<HttpConnection*> invalid_connections;
  11.     //返回出去的可用连接
  12.     HttpConnection* con_ptr = nullptr;
  14.     //加锁
  15.     MutexType::Lock lock(m_mutex);
  17.     //从连接池里找出一个可用的资源
  18.     while(m_connections.size())
  19.     {
  20.         auto con = m_connections.front();
  21.         m_connections.pop_front();
  23.         //当前连接已经断开 视为过期
  24.         if(!con->isConnected())
  25.         {
  26.             invalid_connections.push_back(con);
  27.             continue;
  28.         }
  30.         //当前连接超过了最大存活时间 视为过期
  31.         if(con->getCreateTime() + m_maxAliveTime >= GetCurrentMs())
  32.         {
  33.             invalid_connections.push_back(con);
  34.             continue;
  35.         }
  37.         con_ptr = con;
  38.         break;
  40.     }
  41.     lock.unlock();    //解锁
  43.     //将过期连接资源都要释放
  44.     for(auto &x : invalid_connections)
  45.         delete x;
  47.     m_tatol -= invalid_connections.size();
  49.     //如果在连接池里没有拿到对应的资源 线程创建一个
  50.     if(!con_ptr)
  51.     {
  52.         IPAddress::ptr addr = Address::LookUpAnyIPAddress(m_host);
  53.         if(!addr)
  54.         {
  55.             KIT_LOG_ERROR(g_logger) << "HttpConnectionPool::getConnection get addr fail, host=" << m_host << ", port=" << m_port;
  56.             return nullptr;
  57.         }
  59.         addr->setPort(m_port);
  60.         Socket::ptr sock = Socket::CreateTCP(addr);
  61.         if(!sock)
  62.         {
  63.             KIT_LOG_ERROR(g_logger) << "HttpConnectionPool::getConnection create socket fail, addr=" << *addr;
  64.             return nullptr;
  65.         }
  67.         if(!sock->connect(addr))
  68.         {
  69.             KIT_LOG_ERROR(g_logger) << "HttpConnectionPool::getConnection connect fail, addr=" << *addr;
  70.             return nullptr;
  71.         }
  73.         con_ptr = new HttpConnection(sock);
  74.         ++m_tatol;
  75.     }
  77.     //指定一个用于释放的函数HttpConnectionPool::ReleasePtr
  78.     return HttpConnection::ptr(con_ptr, std::bind(&HttpConnectionPool::ReleasePtr, std::placeholders::_1, this));
  80. }

6.2.3 发起HTTP请求系列函数

6.2.3.1 doRequest(HttpRequest::ptr req, uint64_t timeout_ms);（核心）

功能：负责将HTTP请求发给目标服务器。有多个以此函数为基础，扩展出来的重载函数/便捷接口

  1. /**
  2.  * @brief 负责将HTTP请求发给目标服务器
  3.  * @param[in] req HTTP请求报文智能指针
  4.  * @param[in] timeout_ms 接收响应报文超时时间 
  5.  * @return HttpResult::ptr 返回HTTP连接上操作结果
  6.  */
  7. HttpResult::ptr doRequest(HttpRequest::ptr req, uint64_t timeout_ms);
  9. HttpResult::ptr HttpConnectionPool::doRequest(HttpRequest::ptr req, uint64_t timeout_ms)
  10. {
  11.     //获取HTTP连接资源
  12.     auto con = getConnection();
  13.     if(!con)
  14.     {
  15.         KIT_LOG_ERROR(g_logger) << "HttpConnectionPool::doRequest get connection from pool fail";
  17.         return std::make_shared<HttpResult>((int)HttpResult::Error::POOL_GET_CONNECT_FAIL, nullptr, "get connection from pool fail, host=" + m_host + ", port=" + std::to_string(m_port));
  18.     }
  20.     //通过连接获取到套接字
  21.     auto sock = con->getSocket();
  22.     if(!sock)
  23.     {
  24.         KIT_LOG_ERROR(g_logger) << "HttpConnectionPool::doRequest get sock fail";
  26.         return std::make_shared<HttpResult>((int)HttpResult::Error::POOL_INVALID_SOCK, nullptr, "send request fail, host=" + m_host + ", port=" + std::to_string(m_port));
  27.     }
  28.     //设置接收超时时间
  29.     sock->setRecvTimeout(timeout_ms);
  31.     //通过连接发送HTTP请求报文
  32.     int ret = con->sendRequest(req);
  33.     if(ret < 0)
  34.     {
  35.         KIT_LOG_ERROR(g_logger) << "HttpConnectionPool::DoRequest write fail, errno=" << errno
  36.             << ", is:" << strerror(errno);
  38.         return std::make_shared<HttpResult>((int)HttpResult::Error::SEND_REQ_FAIL, nullptr, "send request fail, addr=" + con->getSocket()->getRemoteAddress()->toString() + ", port=" + std::to_string(m_port) + ", errno=" + std::to_string(errno) + ",is:" + std::string(strerror(errno)));
  39.     }
  41.     //通过连接接收HTTP响应报文
  42.     auto rsp = con->recvResponse();
  43.     if(!rsp)
  44.     {
  45.         KIT_LOG_WARN(g_logger) << "HttpConnectionPool::doRequest recv response maybe timeout, time=" << timeout_ms;
  47.         return std::make_shared<HttpResult>((int)HttpResult::Error::RECV_RSP_TIMEOUT, nullptr, "recv response maybe timeout, ,time=" + std::to_string(timeout_ms) + ",addr=" + con->getSocket()->getRemoteAddress()->toString() + ", errno=" + std::to_string(errno) + ",is:" + std::string(strerror(errno)));
  48.     }
  50.     //返回连接上的收发结果
  51.     return std::make_shared<HttpResult>((int)HttpResult::Error::OK, rsp, "OK");
  52. }

6.2.3.2 重载/便捷接口

  1. /**
  2.  * @brief 使用GET方法将HTTP请求发给目标服务器
  3.  * @param[in] url 指定的目标网址
  4.  * @param[in] timeout_ms 接收超时时间
  5.  * @param[in] headers 指定的首部字段
  6.  * @param[in] body 指定的报文主体
  7.  * @return HttpResult::ptr 返回HTTP连接上操作结果
  8.  */
  9. HttpResult::ptr doGet(const std::string& url, uint64_t timeout_ms, 
  10.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  12. /**
  13.  * @brief 使用POST方法将HTTP请求发给目标服务器
  14.  * @param[in] url 指定的目标网址
  15.  * @param[in] timeout_ms 接收超时时间
  16.  * @param[in] headers 指定的首部字段
  17.  * @param[in] body 指定的报文主体
  18.  * @return HttpResult::ptr 返回HTTP连接上操作结果
  19.  */
  20. HttpResult::ptr doPost(const std::string& url, uint64_t timeout_ms, 
  21.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  23. /**
  24.  * @brief 使用GET方法将HTTP请求发给目标服务器
  25.  * @param[in] uri 指定的URI对象智能指针 
  26.  * @param[in] timeout_ms 接收超时时间
  27.  * @param[in] headers 指定的首部字段
  28.  * @param[in] body 指定的报文主体
  29.  * @return HttpResult::ptr 返回HTTP连接上操作结果
  30.  */
  31. HttpResult::ptr doGet(Uri::ptr uri, uint64_t timeout_ms, 
  32.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  34. /**
  35.  * @brief 使用POST方法将HTTP请求发给目标服务器
  36.  * @param[in] uri 指定的URI对象智能指针 
  37.  * @param[in] timeout_ms 接收超时时间
  38.  * @param[in] headers 指定的首部字段
  39.  * @param[in] body 指定的报文主体
  40.  * @return HttpResult::ptr 返回HTTP连接上操作结果
  41.  */
  42. HttpResult::ptr doPost(Uri::ptr uri, uint64_t timeout_ms, 
  43.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  46. /**
  47.  * @brief 负责将HTTP请求发给目标服务器
  48.  * @param[in] method 指定HTTP请求方法
  49.  * @param[in] url 指定的目标网址
  50.  * @param[in] timeout_ms 接收超时时间
  51.  * @param[in] headers 指定的首部字段
  52.  * @param[in] body 指定的报文主体
  53.  * @return HttpResult::ptr 返回HTTP连接上操作结果
  54.  */
  55. HttpResult::ptr doRequest(HttpMethod method, const std::string& url, uint64_t timeout_ms, 
  56.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  59. /**
  60.  * @brief 负责将HTTP请求发给目标服务器
  61.  * @param[in] method 指定HTTP请求方法
  62.  * @param[in] uri 指定的URI对象智能指针 
  63.  * @param[in] timeout_ms 接收超时时间
  64.  * @param[in] headers 指定的首部字段
  65.  * @param[in] body 指定的报文主体
  66.  * @return HttpResult::ptr 返回HTTP连接上操作结果
  67.  */
  68. HttpResult::ptr doRequest(HttpMethod method, Uri::ptr uri, uint64_t timeout_ms, 
  69.     const std::map<std::string, std::string>& headers = {}, const std::string& body = "");
  1. HttpResult::ptr HttpConnectionPool::doGet(const std::string& url, uint64_t timeout_ms,
  2.     const std::map<std::string, std::string>& headers, const std::string& body)
  3. {   
  4.     return doRequest(HttpMethod::GET, url, timeout_ms, headers, body);
  5. }
  7. HttpResult::ptr HttpConnectionPool::doPost(const std::string& url, 
  8.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  9. {
  10.     return doRequest(HttpMethod::POST, url, timeout_ms, headers, body);
  11. }
  13. HttpResult::ptr HttpConnectionPool::doGet(Uri::ptr uri, 
  14.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  15. {
  16.     std::stringstream ss;
  17.     ss << uri->getPath()
  18.         << (uri->getQuery().size() ? "?" : "")
  19.         << uri->getQuery()
  20.         << (uri->getFragment().size() ? "#" : "")
  21.         << uri->getFragment();
  23.     return doGet(ss.str(), timeout_ms, headers, body);
  24. }
  26. HttpResult::ptr HttpConnectionPool::doPost(Uri::ptr uri, 
  27.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  28. {
  29.     std::stringstream ss;
  30.     ss << uri->getPath()
  31.         << (uri->getQuery().size() ? "?" : "")
  32.         << uri->getQuery()
  33.         << (uri->getFragment().size() ? "#" : "")
  34.         << uri->getFragment();
  36.     return doPost(ss.str(), timeout_ms, headers, body);
  37. }
  40. HttpResult::ptr HttpConnectionPool::doRequest(HttpMethod method, const std::string& url, 
  41.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  42. {
  44.     /*组装HTTP请求报文*/
  45.     HttpRequest::ptr req = std::make_shared<HttpRequest>();
  46.     req->setMethod(method);
  47.     req->setPath(url);
  48.     req->setClose(false);
  50.     bool has_host = false;  //域名标志位
  51.     for(auto &x : headers)
  52.     {
  53.         if(strcasecmp(x.first.c_str(), "connection") == 0 && 
  54.             strcasecmp(x.second.c_str(), "keep-alive") == 0)
  55.         {
  56.                 req->setClose(false);
  57.         }
  59.         //是否存在host域名字段
  60.         if(has_host && strcasecmp(x.first.c_str(), "host") == 0)
  61.             has_host = !x.second.empty();
  63.         req->setHeader(x.first, x.second);
  64.     }
  66.     //没有带域名字段 要使用备用域名m_vhost
  67.     if(!has_host)
  68.     {
  69.         if(!m_vhost.size())
  70.             req->setHeader("host", m_host);
  71.         else 
  72.             req->setHeader("host", m_vhost);
  73.     }
  75.     req->setBody(body);
  77.     return doRequest(req, timeout_ms);
  79. }
  82. HttpResult::ptr HttpConnectionPool::doRequest(HttpMethod method, Uri::ptr uri, 
  83.     uint64_t timeout_ms, const std::map<std::string, std::string>& headers, const std::string& body)
  84. {
  85.     std::stringstream ss;
  86.     //组装URI字符串
  87.     ss << uri->getPath()
  88.         << (uri->getQuery().size() ? "?" : "")
  89.         << uri->getQuery()
  90.         << (uri->getFragment().size() ? "#" : "")
  91.         << uri->getFragment();
  93.     return doRequest(method, ss.str(), timeout_ms, headers, body);
  94. }

C\C++知识点补充复习：fnmatch()函数

功能：检查字符串pattern是否和shell通配符模式字符串string相匹配。flags可以对string中要匹配的模式进行一些设置，具体可以查看一下手册。

返回值：成功匹配返回0， 如果有错返回一个非0值，并且设置errno

  1. #include <fnmatch.h>
  3. int fnmatch(const char *pattern, const char *string, int flags);