【项目日记】仿mudou的高并发服务器 --- 实现HTTP服务器 ...

   对于生命，你不妨大胆一点，      因为我们始终要失去它。        --- 尼采 ---       

---

   ✨✨✨项目地址在这里 ✨✨✨
  ✨✨✨https://gitee.com/penggli_2_0/TcpServer✨✨✨
  

---

  
1 前言

上一篇文章我们基本实现了高并发服务器所需的基础模块，通过TcpServer类可以快速搭建一个TCP服务器。我们的最终目的是使用这个高并发服务器去实现一些业务，那么在网络通讯中，我们就可以来实现一下HTTP服务。让欣赏器可以访问获取数据。
为了实现HTTP服务器首要的工作就是实现HTTP协议，协议是网络通讯的基础！只有确定了协议我们才能正常解析哀求报文，并组织应答报文，可以让欣赏器成功获取数据。
完成HTTP协议之后，就是设计一种报文解析模块，可以从缓冲区中获取数据，举行解析数据，得到完整哀求。
最终将这些整合为一个HTTP服务器模块，设计回调函数，实现HTTP服务器的功能！
2 Util工具类

在HTTP服务器处理处罚中，经常必要一些常用操纵，比如切分字符串，编码转换，通过状态码找到对应状态解析… Util工具类就是用来实现这些功能的类！

• SplitStr
  
  
  
  • 功能：根据指定的分隔符 sep 将字符串 src 切分成多个子字符串，并将这些子字符串存储在 sub 向量中。
    
  • 返回值：返回切分后的子字符串数量。
    
  
  
• ReadFile
  
  
  
  • 功能：以二进制方式读取文件 filename 的内容到字符串 buf 中。
    
  • 返回值：如果文件打开和读取成功，返回 true；否则返回 false。
    
  
  
• WriteFile
  
  
  
  • 功能：以二进制方式将字符串 buf 的内容写入到文件 filename 中，如果文件已存在则覆盖。
    
  • 返回值：如果文件打开和写入成功，返回 true；否则返回 false。
    
  
  
• UrlEncode
  
  
  
  • 功能：对字符串 url 举行 URL 编码，可以选择是否将空格编码为 +。
    
  • 返回值：返回编码后的字符串。
    
  
  
• HexToC
  
  
  
  • 功能：将十六进制字符转换为对应的整数值。
    
  • 返回值：返回转换后的整数值。
    
  
  
• UrlDecode
  
  
  
  • 功能：对字符串 url 举行 URL 解码，可以选择是否将 + 解码为空格。
    
  • 返回值：返回解码后的字符串。
    
  
  
• StatuDesc
  
  
  
  • 功能：根据给定的状态码 code 返回对应的状态形貌。
    
  • 返回值：返回状态形貌字符串，如果状态码未知，则返回 “Unkonw”。
    
  
  
• ExtMime
  
  
  
  • 功能：根据 URL 的扩展名返回对应的 MIME 范例。
    
  • 返回值：返回 MIME 范例字符串，如果扩展名未知，则返回 “application/octet-stream”。
    
  
  
• IsLegPath
  
  
  
  • 功能：查抄字符串 path 是否是合法的路径，重要查抄是否存在非法的 “…” 使用。
    
  • 返回值：如果路径合法，返回 true；否则返回 false。
    
  
  
• IsDir
  
  
  
  • 功能：查抄给定的路径 dir 是否是一个目次。
    
  • 返回值：如果是目次，返回 true；否则返回 false。
    
  
  
• IsRegular
  
  
  
  • 功能：查抄给定的路径 dir 是否是一个常规文件。
    
  • 返回值：如果是常规文件，返回 true；否则返回 false。
    
  
  

1. // 公共方法类
2. class Util
3. {
4. public:
5.     static ssize_t SplitStr(const std::string &src, const std::string &sep, std::vector<std::string> &sub)
6.     {
7.         // 根据sep分隔符切分字符串
8.         int offset = 0; // 偏移量
9.         while (offset < src.size())
10.         {
11.             size_t pos = src.find(sep, offset);
12.             // 没有找到sep
13.             if (pos == std::string::npos)
14.             {
15.                 // 直接将offset后的字符串当成子串
16.                 sub.push_back(src.substr(offset));
17.                 break;
18.             }
19.             // 找到了sep
20.             else
21.             {
22.                 size_t len = pos - offset;
23.                 if (len == 0)
24.                 {
25.                     offset++;
26.                     continue;
27.                 }
29.                 sub.push_back(src.substr(offset, len));
30.                 offset += len; // 偏移量向后移动
31.             }
32.         }
33.         return sub.size();
34.     }
35.     static bool ReadFile(const std::string &filename, std::string *buf)
36.     {
37.         std::ifstream ifs(filename, std::ios::binary); // 以读方式打开文件，采取二进制读取方式
38.         if (ifs.is_open() == false)
39.         {
40.             LOG(ERROR, "Open %s Failed!\n", filename.c_str());
41.             return false;
42.         }
43.         // 获取文件大小
44.         ifs.seekg(0, ifs.end);  // 将读取位置移动到文件末尾
45.         size_t n = ifs.tellg(); // 此时的偏移量即为文件大小
46.         ifs.seekg(0, ifs.beg);  // 将读取位置移动到到文件开头
48.         buf->resize(n); // 将缓冲区大小设置为文件大小
49.         // 进行写入
50.         ifs.read(&(*buf)[0], n);
51.         // 关闭文件
52.         ifs.close();
53.         return true;
54.     }
55.     static bool WriteFile(const std::string &filename, const std::string &buf)
56.     {
57.         std::ofstream ofs(filename, std::ios::binary | std::ios::trunc); // 使用写方式打开进行二进制覆盖写
58.         if (ofs.is_open() == false)
59.         {
60.             LOG(ERROR, "Open %s Failed!\n", filename.c_str());
61.             return false;
62.         }
63.         // 进行写入
64.         ofs.write(&buf[0], buf.size());
65.         if (ofs.good() == false)
66.         {
67.             LOG(ERROR, "Write %s Failed!\n", filename.c_str());
68.             return false;
69.         }
70.         ofs.close();
71.         return true;
72.     }
74.     static std::string UrlEncode(const std::string &url, bool is_space_encode)
75.     {
76.         std::string ret;
77.         // 进行编码
78.         for (auto ch : url)
79.         {
80.             //. - _ ~ 四个字符绝对不编码
81.             // 字母与数字不见编码
82.             if (ch == '.' || ch == '-' || ch == '_' || ch == '~' || isalnum(ch))
83.             {
84.                 ret += ch;
85.                 continue;
86.             }
87.             // 空格编码为 +
88.             if (ch == ' ' && is_space_encode)
89.             {
90.                 ret += '+';
91.                 continue;
92.             }
93.             // 其余字符进行编码
94.             char buf[4]; // 编码格式 %___
95.             snprintf(buf, 4, "%%%02X", ch);
96.             ret += buf;
97.         }
98.         return ret;
99.     }
100.     // URL解码
101.     static char HexToC(char c)
102.     {
103.         if (c >= '0' && c <= '9')
104.         {
105.             return c - '0';
106.         }
107.         else if (c >= 'a' && c <= 'z')
108.         {
109.             return c - 'a' + 10;
110.         }
111.         else if (c >= 'A' && c <= 'Z')
112.         {
113.             return c - 'A' + 10;
114.         }
115.         return -1;
116.     }
117.     static std::string UrlDecode(const std::string &url, bool is_space_decode)
118.     {
119.         std::string res;
120.         // 遍历字符串 遇到%就进行解码
121.         for (int i = 0; i < url.size(); i++)
122.         {
123.             if (url[i] == '%')
124.             {
125.                 char v1 = HexToC(url[i + 1]);
126.                 char v2 = HexToC(url[i + 2]);
127.                 char c = (v1 << 4) + v2;
128.                 res += c;
129.                 i += 2;
130.                 continue;
131.             }
132.             else if (url[i] == '+' && is_space_decode)
133.             {
134.                 res += ' ';
135.                 continue;
136.             }
137.             else
138.             {
139.                 res += url[i];
140.             }
141.         }
142.         return res;
143.     }
144.     // 返回状态码
145.     static std::string StatuDesc(int code)
146.     {
147.         auto ret = _statu_msg.find(code);
148.         if (ret == _statu_msg.end())
149.         {
150.             return "Unkonw";
151.         }
152.         return ret->second;
153.     }
154.     // 解析文件后缀
155.     static std::string ExtMime(const std::string &url)
156.     {
157.         size_t pos = url.rfind('.');
158.         // 没有找到返回
159.         if (pos == std::string::npos)
160.         {
161.             LOG(DEBUG, "没有找到'.'\n");
162.             return "applicantion/octet-stream";
163.         }
164.         std::string str = url.substr(pos);
165.         LOG(DEBUG, "文件类型:%s\n", str.c_str());
166.         auto it = _mime_msg.find(str);
167.         if (it == _mime_msg.end())
168.         {
169.             return "applicantion/octet-stream";
170.         }
171.         return it->second;
172.     }
173.     // 检查是否是合法路径
174.     static bool IsLegPath(const std::string &path)
175.     {
176.         // 采用计数法
177.         int level = 0;
178.         std::vector<std::string> subdir;
179.         int ret = SplitStr(path, "..", subdir);
180.         if (ret < 0)
181.             return false;
182.         for (auto &s : subdir)
183.         {
184.             if (s == "..")
185.             {
186.                 level--;
187.                 if (level < 0)
188.                     return false;
189.                 continue;
190.             }
191.             else
192.                 level++;
193.         }
194.         return true;
195.     }
196.     static bool IsDir(const std::string &dir)
197.     {
198.         struct stat st;
199.         int n = ::stat(dir.c_str(), &st);
200.         if (n < 0)
201.             return false;
202.         return S_ISDIR(st.st_mode);
203.     }
204.     static bool IsRegular(const std::string &dir)
205.     {
206.         struct stat st;
207.         int n = ::stat(dir.c_str(), &st);
208.         if (n < 0)
209.             return false;
210.         return S_ISREG(st.st_mode);
211.     }
212. };

复制代码

3 HTTP协议

3.1 HTTP哀求

http协议的哀求格式是如许的：

• 哀求行：包含哀求方法，资源路径URL，HTTP版本
  
• 哀求报头：以键值对的形式储存须要信息
  
• 空行：用于辨认正文
  
• 哀求正文：储存本次哀求的正文
  
  
  
  针对这个结构我们可以搭建一个HTTP哀求的基础框架：
  

1. class
2. {
3. public:
4.         std::string _method;                                   // 请求方法
5.     std::string _path;                                     // 查询路径
6.     std::string _version;                                  // 协议版本
7.     std::string _body;                                     // 请求正文
8.     std::smatch _matches;                                  // 资源路径的正则提取解析
9.     std::unordered_map<std::string, std::string> _headers; // 请求报头
10.     std::unordered_map<std::string, std::string> _params;  // 查询字符串
11.        
12. };

复制代码

然后继承设置一些接口：

• 插入头部字段的接口
  
• 查抄哀求中是否有该头部字段
  
• 插入查询字符串
  
• 查抄哀求中是否有该查询字符串
  
• 获取查询字符串
  
• 获取正文长度
  
• 是否为长连接
  

1. class HttpRequest
2. {
3. public:
4.     std::string _method;                                   // 请求方法
5.     std::string _path;                                     // 查询路径
6.     std::string _version;                                  // 协议版本
7.     std::string _body;                                     // 请求正文
8.     std::smatch _matches;                                  // 资源路径的正则提取解析
9.     std::unordered_map<std::string, std::string> _headers; // 请求报头
10.     std::unordered_map<std::string, std::string> _params;  // 查询字符串
11. public:
12.     // 重置请求
13.     void Reset()
14.     {
15.         _method.clear();
16.         _path.clear();
17.         _version.clear();
18.         _body.clear();
19.         std::smatch tmp;
20.         _matches.swap(tmp);
21.         _headers.clear();
22.         _params.clear();
23.     }
24.     // 插入头部字段
25.     void SetHeader(const std::string &key, const std::string &val)
26.     {
27.         _headers.insert(std::make_pair(key, val));
28.     }
29.     // 判断是否有该头部字段
30.     bool HasHeader(const std::string &key) const
31.     {
32.         auto it = _headers.find(key);
33.         if (it == _headers.end())
34.         {
35.             return false;
36.         }
37.         return true;
38.     }
39.     // 获取头部字段
40.     std::string GetHeader(const std::string &key) const
41.     {
42.         auto it = _headers.find(key);
43.         if (it == _headers.end())
44.         {
45.             return "";
46.         }
47.         return it->second;
48.     }
49.     // 插入查询字符串
50.     void SetParam(const std::string &key, const std::string &val)
51.     {
52.         _params.insert(std::make_pair(key, val));
53.     }
54.     // 判断是否有该查询字符串
55.     bool HasParam(const std::string &key)
56.     {
57.         auto it = _params.find(key);
58.         if (it == _params.end())
59.         {
60.             return false;
61.         }
62.         return true;
63.     }
64.     // 获取查询字符串
65.     std::string GetParam(const std::string &key)
66.     {
67.         auto it = _params.find(key);
68.         if (it == _params.end())
69.         {
70.             return "";
71.         }
72.         return it->second;
73.     }
74.     // 获取正文长度
75.     size_t ContentLength()
76.     {
77.         bool ret = HasHeader("Content-Length");
78.         if (ret)
79.         {
80.             // 转换为长整形
81.             return std::stol(GetHeader("Content-Length"));
82.         }
83.         return 0;
84.     }
85.     bool Close() const
86.     {
87.         // 没有Connection字段或者Connection字段是close 就是短连接
88.         if (HasHeader("Connection") == true && GetHeader("Connection") == "close")
89.         {
90.             return true;
91.         }
92.         return false;
93.     }
94. };

复制代码

如许一个基础的HTTP哀求结构就设计好了！
3.2 HTTP应答

http协议的应答格式是如许的：

• 状态行：包含HTTP版本，状态码，状态码形貌
  
• 应答报头：储存须要信息
  
• 换行符：用于辨认正文
  
• 正文：储存应答的正文结构
  

根据应答结构，我们可以搭建其应答框架：

• 设置头部字段
  
• 获取头部字段
  
• 设置正文
  
• 设置应答状态
  
• 是否是长连接
  

1. class HttpResponse
2. {
3. public:
4.     int _statu;                                            // 状态码
5.     bool _rediect_flag;                                    // 重定向标志
6.     std::string _rediect_url;                              // 重定向的路径
7.     std::string _body;                                     // 响应正文
8.     std::unordered_map<std::string, std::string> _headers; // 响应报头
10. public:
11.     HttpResponse(int statu) : _statu(statu) {}
12.     // 重置响应
13.     void Reset()
14.     {
15.     }
16.     // 插入头部字段
17.     void SetHeader(const std::string &key, const std::string &val)
18.     {
19.         _headers.insert(std::make_pair(key, val));
20.     }
21.     // 判断是否有该头部字段
22.     bool HasHeader(const std::string &key)
23.     {
24.         auto it = _headers.find(key);
25.         if (it == _headers.end())
26.         {
27.             return false;
28.         }
29.         return true;
30.     }
31.     // 获取头部字段
32.     std::string GetHeader(const std::string &key)
33.     {
34.         auto it = _headers.find(key);
35.         if (it == _headers.end())
36.         {
37.             return "";
38.         }
39.         return it->second;
40.     }
41.     void SetContent(const std::string &body, const std::string &type = "text/html")
42.     {
43.         _body = body;
44.         SetHeader("Content-Type", type);
45.     }
46.     void SetRediret(const std::string &url, int statu = 302)
47.     {
48.         _statu = statu;
49.         _rediect_flag = true;
50.         _rediect_url = url;
51.     }
52.     bool Close()
53.     {
54.         // 没有Connection字段或者Connection字段是close 就是短连接
55.         if (HasHeader("Connection") == true && GetHeader("Connection") == "close")
56.         {
57.             return true;
58.         }
59.         return false;
60.     }
61. };

复制代码

如许HTTP协议的哀求与应答我们就完成了！可以进一步举行哀求与应答的解析工作了！
4 上下文解析模块

针对应答的反序列化，我们不在协议模块中直接举行设置，因为我们无法保证连接一次就可以获取完整的报文结构，以是在一个连接中要维护一个上下文结构，可以在多次处理处罚时知道本次处理处罚应该从那边举行！
在这个上下文中起首我们就必要一个状态变量，可以标识当前应该处理处罚什么字段：

1.     RECV_HTTP_ERROR --- 处理出错
2.     RECV_HTTP_LINE --- 处理请求行
3.     RECV_HTTP_HEAD --- 处理头部字段
4.     RECV_HTTP_BODY --- 处理正文
5.     RECV_HTTP_OVER --- 处理完成

复制代码

每一个上下文都匹配一个哀求对象，将解析好的字段储存到这个哀求对象中：

• 处理处罚哀求行：处理处罚哀求行时使用正则表达式快速举行处理处罚，注意URL编码的转换，哀求方法的巨细写以及拆分出查询字符串！
  
• 处理处罚头部字段：一行一行的举行处即可，直到碰到空行！
  
• 处理处罚正文：从缓冲区读取出正文长度的数据，不够继承等待，够了就返回。
  

必要注意的是，获取数据时不一定会获取到预期的数据，一定要做好情况分类，保证正常读取！
制止出现数据过长，数据不敷等情况！
上下文每次解析都将数据及时储存到该上下文中对应的哀求对象中！

1. typedef enum
2. {
3.     RECV_HTTP_ERROR,
4.     RECV_HTTP_LINE,
5.     RECV_HTTP_HEAD,
6.     RECV_HTTP_BODY,
7.     RECV_HTTP_OVER
8. } HttpRecvStatu;
10. static const int MAX_SIZE = 8192;
12. class HttpContext
13. {
14. private:
15.     int _resp_statu;           // 响应状态码
16.     HttpRequest _request;      // 请求信息
17.     HttpRecvStatu _recv_statu; // 解析状态
18. private:
19.     bool ParseHttpLine(const std::string &line)
20.     {
21.         // 对请求行进行正则表达式解析
22.         // 设置解析方法： 忽略大小写！
23.         // std::regex re("(GET|HEAD|POST|PUT|DELETE) ([^?]+)\\?(.*) (HTTP/1\\.[01])(?:\n|\r\n)?", std::regex::icase);
24.         std::regex re("(GET|HEAD|POST|PUT|DELETE) ([^?]*)(?:\\?(.*))? (HTTP/1\\.[01])(?:\n|\r\n)?", std::regex::icase);
25.         //(GET|HEAD|POST|PUT|DELETE) 获取GET...请求方法
26.         //([^?]+) 匹配若干个 非？字符 直到？ --- 获取资源路径
27.         //\\?(.*) \\?表示匹配原始？字符 (.*)访问到空格 ---获取请求参数
28.         //(HTTP/1\\.[01]) 匹配HTTP/1. 01任意一个字符
29.         //(?:\n|\r\n)? 匹配\n或者\r\n (?: ...)表示匹配摸个格式字符串但是不提取 .结尾的？表示前面的表达式0次或1次
30.         std::smatch matches;
31.         bool ret = std::regex_match(line, matches, re);
32.         if (ret == false)
33.         {
34.             LOG(ERROR, "regex_match failed\n");
35.             _resp_statu = 400; // Bad Reauest!
36.             return false;
37.         }
38.         // 0:GET /a/b/c/search?q=keyword&lang=en HTTP/1.1
39.         // 1:GET
40.         // 2:/a/b/c/search
41.         // 3:q=keyword&lang=en
42.         // 4:HTTP/1.1
43.         _request._method = matches[1];
44.         // 请求方法统一转换为大写
45.         std::transform(_request._method.begin(), _request._method.end(), _request._method.begin(), ::toupper);
46.         _request._path = Util::UrlDecode(matches[2], false);
47.         _request._version = matches[4];
48.         // 对查询字符串进行解析
49.         std::string str = matches[3];
50.         std::vector<std::string> substr;
51.         // 进行切分字符串
52.         Util::SplitStr(str, "&", substr);
53.         // 遍历容器
54.         for (auto s : substr)
55.         {
56.             // 寻找'='
57.             size_t pos = s.find("=");
58.             if (pos == std::string::npos)
59.             {
60.                 LOG(ERROR, "ParseHttpLine Failed\n");
61.                 _recv_statu = RECV_HTTP_ERROR;
62.                 _resp_statu = 400; // BAD Resquest
63.                 return false;
64.             }
65.             // 找到了 ‘=’
66.             std::string key = Util::UrlDecode(s.substr(0, pos), true);
67.             std::string value = Util::UrlDecode(s.substr(pos + 1), true);
68.             LOG(INFO, "查询字符串%s: %s\n", key.c_str(), value.c_str());
69.             _request.SetParam(key, value);
70.         }
72.         return true;
73.     }
74.     // 解析请求行
75.     bool RecvHttpLine(Buffer *buf)
76.     {
77.         if (_recv_statu != RECV_HTTP_LINE)
78.             return false;
79.         // 获取一行数据 带有\r\n
80.         std::string line = buf->GetLineAndPop();
81.         if (line.size() == 0)
82.         {
83.             // 缓存区中没有完整的一行数据 进行分类讨论
84.             // 如果缓冲区数据大于极限值
85.             if (buf->ReadAbleSize() > MAX_SIZE)
86.             {
87.                 _resp_statu = 414; // URL TOO LONG
88.                 _recv_statu = RECV_HTTP_ERROR;
89.                 return false;
90.             }
91.             // 反之不处理
92.             return true;
93.         }
94.         // 一行的数据过长
95.         if (line.size() > MAX_SIZE)
96.         {
97.             _resp_statu = 414; // URL TOO LONG
98.             _recv_statu = RECV_HTTP_ERROR;
99.             return false;
100.         }
101.         // 进行解析
102.         bool ret = ParseHttpLine(line);
103.         if (ret == false)
104.             return false;
105.         // 请求行解析完毕 开始解析请求报头
106.         _recv_statu = RECV_HTTP_HEAD;
107.         return true;
108.     }
109.     // 解析报头
110.     bool RecvHttpHead(Buffer *buf)
111.     {
112.         if (_recv_statu != RECV_HTTP_HEAD)
113.             return false;
114.         // 解析请求报头直到遇到空行
115.         while (1)
116.         {
117.             std::string line = buf->GetLineAndPop();
118.             // LOG(DEBUG, "line:%s\n", line.c_str());
119.             if (line.size() == 0)
120.             {
121.                 // 缓存区中没有完整的一行数据 进行分类讨论
122.                 // 如果缓冲区数据大于极限值
123.                 if (buf->ReadAbleSize() > MAX_SIZE)
124.                 {
125.                     // LOG(ERROR, "line too long\n");
126.                     _resp_statu = 414; // URL TOO LONG
127.                     _recv_statu = RECV_HTTP_ERROR;
128.                     return false;
129.                 }
130.                 // 反之不处理 等待新数据到来
131.                 // LOG(ERROR, "wait new buffer\n");
132.                 return true;
133.             }
134.             // 一行的数据过长
135.             if (line.size() > MAX_SIZE)
136.             {
137.                 // LOG(ERROR, "line too long\n");
138.                 _resp_statu = 414; // URL TOO LONG
139.                 _recv_statu = RECV_HTTP_ERROR;
140.                 return false;
141.             }
142.             if (line == "\n" || line == "\r\n")
143.             {
144.                 // LOG(ERROR, "line is empty\n");
145.                 break;
146.             }
147.             // LOG(INFO, "line正常 进行解析处理");
148.             //  去除换行 \r \n
149.             if (line.back() == '\n')
150.                 line.pop_back();
151.             if (line.back() == '\r')
152.                 line.pop_back();
153.             // 进行解析
154.             bool ret = ParseHttpHead(line);
155.             if (ret == false)
156.                 return false;
157.         }
158.         // 头部解析完成 继续解析正文
159.         _recv_statu = RECV_HTTP_BODY;
160.         return true;
161.     }
162.     bool ParseHttpHead(const std::string &line)
163.     {
164.         // 每一行都是key: val\r\n 格式
165.         // LOG(DEBUG, "ParseHttpHead:%s\n", line.c_str());
166.         // 进行解析即可
167.         size_t pos = line.find(": ");
168.         if (pos == std::string::npos)
169.         {
170.             LOG(ERROR, "ParseHttpLine Failed\n");
171.             _recv_statu = RECV_HTTP_ERROR;
172.             _resp_statu = 400; // BAD Resquest
173.             return false;
174.         }
175.         std::string key = line.substr(0, pos);
176.         std::string val = line.substr(pos + 2);
177.         // LOG(DEBUG, "%s: %s\n", key.c_str(), val.c_str());
178.         _request.SetHeader(key, val);
179.         return true;
180.     }
181.     bool RecvHttpBody(Buffer *buf)
182.     {
183.         if (_recv_statu != RECV_HTTP_BODY)
184.             return false;
185.         // 获取正文长度
186.         size_t len = _request.ContentLength();
187.         // 没有正文 直接读取完毕
188.         if (len == 0)
189.         {
190.             _recv_statu = RECV_HTTP_OVER;
191.             return true;
192.         }
193.         // 当前已经接受了多少数据 _request._body
194.         size_t relen = len - _request._body.size();
195.         // 接收正文放到body中 但是要考虑当前缓冲区中的数据是否是全部的报文
196.         // 缓冲区数据包含所有正文
197.         if (relen <= buf->ReadAbleSize())
198.         {
199.             // 加到_request.body的后面
200.             _request._body.append(buf->ReadPos(), relen);
201.             buf->MoveReadOffset(relen);
202.             _recv_statu = RECV_HTTP_OVER;
203.             return true;
204.         }
205.         // 缓冲区无法满足正文
206.         _request._body.append(buf->ReadPos(), buf->ReadAbleSize());
207.         buf->MoveReadOffset(buf->ReadAbleSize());
208.         return true;
209.     }
211. public:
212.     HttpContext() : _resp_statu(200), _recv_statu(RECV_HTTP_LINE) {}
213.     int RespStatu() { return _resp_statu; }
214.     HttpRequest &Request() { return _request; }
215.     HttpRecvStatu RecvStatu() { return _recv_statu; }
216.     // 重置上下文
217.     void Reset()
218.     {
219.         _resp_statu = 200;
220.         _recv_statu = RECV_HTTP_LINE;
221.         _request.Reset();
222.     }
223.     void RecvhttpRequest(Buffer *buf)
224.     {
225.         // 根据不同的状态 处理不同情况
226.         // 处理完不要break 因为处理完 可以继续进行处理下面的数据 而不是直接退出等待新数据！
227.         switch (_recv_statu)
228.         {
229.         case RECV_HTTP_LINE:
230.             RecvHttpLine(buf);
231.         case RECV_HTTP_HEAD:
232.             RecvHttpHead(buf);
233.         case RECV_HTTP_BODY:
234.             RecvHttpBody(buf);
235.         }
236.         return;
237.     }
238. };

复制代码

5 HTTP服务器对象

现在，HTTP协议我们实现了，可以通过协议举行通讯！如何通过缓冲区获取哀求的上下文方法我们也实现了，可以在缓冲区中读取数据，纵然一次没有发送全，下一次可以继承在原有进度上继承举行解析！
那么接下来，我们对这些功能举行一个整合封装，实现HTTP服务器的功能！
起首这个模块中有哀求方法/资源路径 与 函数指针的映射关系表，可以根据http哀求的url找到对应的资源

• 表中纪录了对于哪个哀求，应该使用哪一个函数来举行业务处理处罚
  
• 当服务器收到一个哀求，就要在哀求路由表中，查找是否存在对应的处理处罚函数，没有就返回404 Not Found
  
• 如许做的利益是用户只必要实现业务处理处罚函数，然后将哀求与函数的对应关系添加到服务器中，服务器只必要接收数据，解析数据，查找路由表映射关系，执行业务处理处罚函数！
  

要实现简便的搭建Http服务器，所需的要素和提供的功能有以下几项：

• GET哀求的路由映射表 — 功能性哀求的处理处罚
  
• POST哀求的路由映射表
  
• PUT哀求的路由映射表
  
• DELETE哀求的路由映射表
  
• 高性能TCP服务器 — 举行连接的IO操纵
  
• 静态资源相对根目次 — 实现静态资源的处理处罚
  

再来看服务器的处理处罚流程，只有认识了服务器处理处罚流程，才能明白代码逻辑然后举行功能实现！

• 从Socket接收数据。放到接收缓冲区
  
• 调用OnMessage回调函数举行业务处理处罚
  
• 对哀求举行解析,得到一个HttpRequest结构，包含全部的哀求要素
  
• 举行哀求的路由查找 — 找到对应哀求的处理处罚方法
  
  
  
  • 静态资源哀求 — 一些实体文件资源的哀求
    
  • 功能性哀求 — 在哀求中根据路由映射表查找处理处罚函数
    
  
  
• 对静态资源哀求/功能性哀求举行处理处罚完毕后，得到了一个填充了相应信息的HttpReaponse对象，组成http格式报文
  

   成员变量：   

• GET哀求的路由映射表 _get_route — 通过正则表达式映射处理处罚函数
  
• POST哀求的路由映射表 _post_route
  
• PUT哀求的路由映射表 _put_route
  
• DELETE哀求的路由映射表 _delete_route
  
• 静态资源根目次 _basedir
  
• TcpServer服务器 _server
  

   私有成员函数   

• 设置上下文 OnConnect(const PtrConn& conn)：给连接设置空的上下文
  
• 缓冲区数据解析+处理处罚 OnMessage(const PtrConn& conn , Buffer *buf)：只要缓冲区里有数据就持续处理处罚起首先获取上下文，通过上下文对缓冲区数据举行处理处罚得到HttpRequest对象，根据状态码>= 400判断解析结果 ，如果解析堕落 ，直接复兴堕落相应 ErrorHandler(req , rsp) 并关闭连接！ 哀求解析不完整 直接return 等待下一次处理处罚。直到解析完毕 才去举行数据处理处罚。然后举行哀求路由Route(req ,&rsp) 在路由中举行数据处理处罚业务处理处罚，处理处罚后得到应答报文，对HttpResponse 举行组织发送 WriteResponse(const PtrConn& conn , req , rsp)此时重置连接的上下文！根据长短连接判断是否要关闭连接大概继承保持连接
  
• 路由查找 Route：对哀求举行判断，是哀求静态资源还是功能性哀求
  
  
  
  • 静态资源哀求 ：判断是否是静态资源哀求，然后举行静态资源的处理处罚
    
  • 功能性哀求 ： 通过req的哀求方法判断使用哪一个路由表，使用Dispatch举行任务派发
    
  • 既不是静态资源一样平常是功能性哀求 就返回404！
    
  
  
• 判断是否是静态资源哀求 IsFileHandler：起首必须设置了静态资源根目次，哀求方法必须是GET / HEAD
  ，哀求的资源路径必须是合法路径，哀求的资源必须存在！ 当哀求路径是"/"要补全一个初始页面 index.html，注意合并_basedir得到真正的路径！
  
• 静态资源的哀求处理处罚 FileHandler：将静态资源的数据读取出来，放到rsp的正文中，直接读取路径上的文件放到正文中，获取mime文件范例，添加到头部字段Content-Type！
  
• 功能性哀求的任务分发 Dispatcher：在对应路由表中探求是否有对应哀求的处理处罚函数，有就直接举行调用 没有就返回404。路由表中储存的是 正则表达式->处理处罚函数 的键值对。使用正则表达式举行匹配 ，匹配成功就举行执行函数
  
• 发送应答WriteResponse：将HttpReaponse应答按照http应答格式举行组织发送 ，起首完善头部字段 ，然后将rsp的元素按照http协议的格式举行组织，最终发送数据
  
• 处理处罚错误应答ErrorHandler： 提供一个错误展示页面，将页面数据当作相应正文放入rsp中
  

   公有成员函数：   

• 构造函数
  
• 插入关系映射到GET路由表、POST路由表、PUT路由表、DELETE路由表。
  
• 设置静态资源根目次
  
• 设置线程数量
  
• 启动Http服务器
  

1. class HttpServer
2. {
3. private:
4.     using Handler = std::function<void(const HttpRequest &, HttpResponse *)>;
5.     using Handlers = std::vector<std::pair<std::regex, Handler>>;
6.     Handlers _get_route;    // GET方法处理函数映射表
7.     Handlers _post_route;   // POST方法处理函数映射表
8.     Handlers _delete_route; // DELETE方法处理函数映射表
9.     Handlers _put_route;    // PUT方法处理函数映射表
10.     std::string _basedir;
11.     TcpServer _server;
13. public:
14.     // 设置空白上下文
15.     void OnConnect(const PtrConn &conn)
16.     {
17.         conn->SetContext(HttpContext());
18.         LOG(INFO, "NEW CONNECTION :%p\n", this);
19.     }
20.     void ErrorHandler(const HttpRequest &req, HttpResponse *rsp)
21.     {
22.         // 提供一个错误展示页面
23.         std::string body;
24.         body += "<!DOCTYPE html>";
25.         body += "<html lang='en'>";
26.         body += "<head>";
27.         body += "<meta charset='UTF-8'>";
28.         body += "<meta name='viewport' content='width=device-width, initial-scale=1.0'>";
29.         body += "<title>Error " + std::to_string(rsp->_statu) + " - Server Error</title>";
30.         body += "<style>";
31.         body += "body { background-color: #f2f2f2; color: #333; font-family: Arial, sans-serif; }";
32.         body += "h1 { color: #d8000c; background-color: #ffbaba; border: 1px solid #d8d8d8; padding: 10px; text-align: center; }";
33.         body += "div.container { max-width: 600px; margin: 50px auto; padding: 20px; background-color: #fff; border-radius: 8px; box-shadow: 0 0 10px rgba(0,0,0,0.1); }";
34.         body += "</style>";
35.         body += "</head>";
36.         body += "<body>";
37.         body += "<div class='container'>";
38.         body += "<h1>";
39.         body += "Error " + std::to_string(rsp->_statu) + " - " + Util::StatuDesc(rsp->_statu);
40.         body += "</h1>";
41.         body += "<p>We're sorry, but something went wrong.</p>";
42.         body += "</div>";
43.         body += "</body>";
44.         body += "</html>";
46.         // 将页面数据，当作响应正文，放入rsp中
47.         rsp->SetContent(body, "text/html");
48.     }
50.     // 缓冲区数据解析+处理
51.     void OnMessage(const PtrConn &conn, Buffer *buf)
52.     {
53.         while (buf->ReadAbleSize() > 0)
54.         {
55.             // 从连接中获取上下文
56.             HttpContext *context = conn->GetContext()->Get<HttpContext>();
57.             // 从缓冲区中获取数据 处理后得到Request
58.             context->RecvhttpRequest(buf);
59.             HttpRequest req = context->Request();
60.             // 根据请求构建应答
61.             HttpResponse rsp(context->RespStatu());
62.             // 根据状态码判断处理结果
63.             // LOG(DEBUG, "res->statu :%d\n", rsp._statu);
64.             // 状态码大于400说明解析出错 直接退出
65.             if (context->RespStatu() >= 400)
66.             {
67.                 // 重置上下文
68.                 context->Reset();
69.                 // 清空缓冲区
70.                 buf->MoveReadOffset(buf->ReadAbleSize());
71.                 // 获取错误响应
72.                 ErrorHandler(req, &rsp);
73.                 // 发送错误请求
74.                 WriteResponse(conn, req, rsp);
75.                 // 关闭连接
76.                 conn->Shutdown();
77.                 return;
78.             }
79.             // 如果解析没有完成就等待下一次处理
80.             if (context->RecvStatu() != RECV_HTTP_OVER)
81.             {
82.                 // 退出等待新数据到来 重新进行处理
83.                 return;
84.             }
85.             // 请求解析完成进行处理
86.             Route(req, &rsp);
87.             LOG(INFO, "%s\n", rsp._body.c_str());
88.             if (rsp._statu >= 400)
89.             {
90.                 // 获取错误响应
91.                 ErrorHandler(req, &rsp);
92.                 // 发送错误请求
93.                 WriteResponse(conn, req, rsp);
94.                 // 重置上下文
95.                 context->Reset();
96.                 // 关闭连接
97.                 conn->Shutdown();
98.                 return;
99.             }
100.             // 获取应答
101.             WriteResponse(conn, req, rsp);
102.             // 重置上下文
103.             context->Reset();
104.             // 根据长短连接判断是否需要关闭连接
105.             if (rsp.Close() == true)
106.                 conn->Shutdown();
107.         }
108.         return;
109.     }
111.     bool Route(HttpRequest &req, HttpResponse *rsp)
112.     {
113.         // 判断是否是静态资源处理
114.         if (IsFileHandler(req) == true)
115.             return FileHandler(req, rsp);
117.         // 判断是否实际功能性请求
118.         if (req._method == "GET" || req._method == "HEAD")
119.             return Dispatcher(req, rsp, _get_route);
120.         else if (req._method == "POST")
121.             return Dispatcher(req, rsp, _post_route);
122.         else if (req._method == "PUT")
123.             return Dispatcher(req, rsp, _put_route);
124.         else if (req._method == "DELETE")
125.             return Dispatcher(req, rsp, _delete_route);
126.         // 不是静态请求也不是功能性请求
127.         else
128.         {
129.             rsp->_statu = 405; // Method Not Allowed
130.             return false;
131.         }
132.     }
133.     // 判断是否是静态资源
134.     bool IsFileHandler(HttpRequest &req)
135.     {
136.         // 首先_basedir必须存在
137.         if (_basedir.empty() == true)
138.             return false;
139.         // 请求方法必须是 GET / HEAD
140.         if (req._method != "GET" && req._method != "HEAD")
141.             return false;
142.         // 请求路径必须是合法路径
143.         if (Util::IsLegPath(req._path) == false)
144.             return false;
145.         // 请求的资源必须存在
146.         std::string req_path = _basedir + req._path;
147.         // 如果直接请求的网络根目录要补全一个初始页面
148.         if (req_path.back() == '/')
149.             req_path += "index.html";
150.         if (Util::IsRegular(req_path) == false)
151.             return false;
152.         // req请求路径的真正路径
153.         req._path = req_path;
154.         return true;
155.     }
156.     // 静态资源的请求处理
157.     bool FileHandler(HttpRequest &req, HttpResponse *rsp)
158.     {
159.         LOG(INFO, "静态资源请求:%s\n", req._path.c_str());
160.         // 将请求资源读取到应答正文中
161.         bool ret = Util::ReadFile(req._path, &rsp->_body);
162.         if (ret == false)
163.         {
164.             // 数据读取失败
165.             LOG(ERROR, "数据读取失败\n");
166.             return false;
167.         }
168.         // 获取文件类型mime
169.         std::string mime = Util::ExtMime(req._path);
170.         LOG(DEBUG, "Content-Type:%s\n", mime.c_str());
171.         // 添加到应答报头
172.         rsp->SetHeader("Content-Type", mime);
173.         return true;
174.     }
175.     // 功能性请求的任务分发
176.     bool Dispatcher(HttpRequest &req, HttpResponse *rsp, Handlers &handlers)
177.     {
178.         // LOG(INFO, "%s 功能性请求:%s\n", req._method.c_str(), req._path.c_str());
179.         //  首先根据路由表找到目标
180.         for (auto &handler : handlers)
181.         {
182.             const std::regex &re = handler.first;
183.             // 根据这个正则表达式进行解析
184.             bool ret = std::regex_match(req._path, req._matches, re);
185.             if (ret == false)
186.                 continue;
187.             // 找到了就进行执行函数
188.             Handler Functor = handler.second;
189.             Functor(req, rsp);
190.             return true;
191.         }
192.         // 没有找到目标
193.         LOG(DEBUG, "404 Not Found\n");
194.         rsp->_statu = 404; // 设置为Not Found
195.         return false;
196.     }
197.     // 将HttpReaponse应答按照http应答格式进行组织发送
198.     void WriteResponse(const PtrConn &conn, const HttpRequest &req, HttpResponse &rsp)
199.     {
200.         // 首先先完善头部字段
201.         if (req.Close() == true)
202.             rsp.SetHeader("Connection", "close");
203.         else
204.             rsp.SetHeader("Connection", "keep-alive");
205.         if (rsp._body.empty() == true && rsp.HasHeader("Content-Length") == false)
206.             rsp.SetHeader("Content-Length", std::to_string(rsp._body.size()));
207.         if (rsp._body.empty() == true && rsp.HasHeader("Content-Type") == false)
208.             rsp.SetHeader("Content-Type", "application/octet-stream");
209.         if (rsp._rediect_flag == true)
210.             rsp.SetHeader("Location", rsp._rediect_url);
211.         // 将rsp组织成http格式的应答报文
212.         std::stringstream rsp_str;
213.         rsp_str << req._version << " " << std::to_string(rsp._statu) << " " << Util::StatuDesc(rsp._statu) << "\r\n";
214.         for (auto &it : rsp._headers)
215.         {
216.             rsp_str << it.first << ": " << it.second << "\r\n";
217.         }
218.         rsp_str << "\r\n";
219.         rsp_str << rsp._body << "\r\n";
220.         // 进行发送
221.         // LOG(INFO, "WriteResponse Send :%s \n", rsp_str.str().c_str());
222.         conn->Send(rsp_str.str().c_str(), rsp_str.str().size());
223.     }
225. public:
226.     HttpServer(int port, int timeout = DEFALT_TIMEOUT) : _server(port)
227.     {
228.         _server.SetConnectCB(std::bind(&HttpServer::OnConnect, this, std::placeholders::_1));
229.         _server.SetMessageCB(std::bind(&HttpServer::OnMessage, this, std::placeholders::_1, std::placeholders::_2));
230.         _server.EnableActiveRelease(timeout); // 设置超时时间
231.     }
232.     // 插入关系映射到GET路由表
233.     void GET(const std::string &pattern, const Handler &func) { _get_route.push_back(std::make_pair(std::regex(pattern), func)); }
234.     void POST(const std::string &pattern, const Handler &func) { _post_route.push_back(std::make_pair(std::regex(pattern), func)); }
235.     void PUT(const std::string &pattern, const Handler &func) { _put_route.push_back(std::make_pair(std::regex(pattern), func)); }
236.     void DELETE(const std::string &pattern, const Handler &func) { _delete_route.push_back(std::make_pair(std::regex(pattern), func)); }
237.     void SetBaseDir(const std::string &dir)
238.     {
239.         assert(Util::IsDir(dir) == true);
240.         _basedir = dir;
241.     }
242.     // 设置服务器线程数量
243.     void SetThreadSize(size_t size)
244.     {
245.         _server.SetThreadSize(size);
246.     }
247.     // 启动服务器
248.     void Start()
249.     {
250.         _server.Start();
251.     }
252. };

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。