文章目录
本篇是对于Loop并发服务器的补充,基于其内容搭建一个Http服务器,详情可以查看项目
HTTP模块
本项目对于HTTP协议只是提供一个支持的功能,下面对于要进行的模块进行讲述,但并不是本项目的重点内容,重点还是在前面的部分
Util模块
该模块主要是对于HTTP协议模块需要用到的工具函数进行使用,比如有例如url编解码,还有文件的读写等等内容
#pragma once
#include <vector>
#include <unordered_map>
#include <string>
#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "Log.hpp"
using namespace std;
unordered_map<int, string> _statu_msg = {
{100, "Continue"},
{101, "Switching Protocol"},
{102, "Processing"},
{103, "Early Hints"},
{200, "OK"},
{201, "Created"},
{202, "Accepted"},
{203, "Non-Authoritative Information"},
{204, "No Content"},
{205, "Reset Content"},
{206, "Partial Content"},
{207, "Multi-Status"},
{208, "Already Reported"},
{226, "IM Used"},
{300, "Multiple Choice"},
{301, "Moved Permanently"},
{302, "Found"},
{303, "See Other"},
{304, "Not Modified"},
{305, "Use Proxy"},
{306, "unused"},
{307, "Temporary Redirect"},
{308, "Permanent Redirect"},
{400, "Bad Request"},
{401, "Unauthorized"},
{402, "Payment Required"},
{403, "Forbidden"},
{404, "Not Found"},
{405, "Method Not Allowed"},
{406, "Not Acceptable"},
{407, "Proxy Authentication Required"},
{408, "Request Timeout"},
{409, "Conflict"},
{410, "Gone"},
{411, "Length Required"},
{412, "Precondition Failed"},
{413, "Payload Too Large"},
{414, "URI Too Long"},
{415, "Unsupported Media Type"},
{416, "Range Not Satisfiable"},
{417, "Expectation Failed"},
{418, "I'm a teapot"},
{421, "Misdirected Request"},
{422, "Unprocessable Entity"},
{423, "Locked"},
{424, "Failed Dependency"},
{425, "Too Early"},
{426, "Upgrade Required"},
{428, "Precondition Required"},
{429, "Too Many Requests"},
{431, "Request Header Fields Too Large"},
{451, "Unavailable For Legal Reasons"},
{501, "Not Implemented"},
{502, "Bad Gateway"},
{503, "Service Unavailable"},
{504, "Gateway Timeout"},
{505, "HTTP Version Not Supported"},
{506, "Variant Also Negotiates"},
{507, "Insufficient Storage"},
{508, "Loop Detected"},
{510, "Not Extended"},
{511, "Network Authentication Required"}};
unordered_map<string, string> _mime_msg = {
{".aac", "audio/aac"},
{".abw", "application/x-abiword"},
{".arc", "application/x-freearc"},
{".avi", "video/x-msvideo"},
{".azw", "application/vnd.amazon.ebook"},
{".bin", "application/octet-stream"},
{".bmp", "image/bmp"},
{".bz", "application/x-bzip"},
{".bz2", "application/x-bzip2"},
{".csh", "application/x-csh"},
{".css", "text/css"},
{".csv", "text/csv"},
{".doc", "application/msword"},
{".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
{".eot", "application/vnd.ms-fontobject"},
{".epub", "application/epub+zip"},
{".gif", "image/gif"},
{".htm", "text/html"},
{".html", "text/html"},
{".ico", "image/vnd.microsoft.icon"},
{".ics", "text/calendar"},
{".jar", "application/java-archive"},
{".jpeg", "image/jpeg"},
{".jpg", "image/jpeg"},
{".js", "text/javascript"},
{".json", "application/json"},
{".jsonld", "application/ld+json"},
{".mid", "audio/midi"},
{".midi", "audio/x-midi"},
{".mjs", "text/javascript"},
{".mp3", "audio/mpeg"},
{".mpeg", "video/mpeg"},
{".mpkg", "application/vnd.apple.installer+xml"},
{".odp", "application/vnd.oasis.opendocument.presentation"},
{".ods", "application/vnd.oasis.opendocument.spreadsheet"},
{".odt", "application/vnd.oasis.opendocument.text"},
{".oga", "audio/ogg"},
{".ogv", "video/ogg"},
{".ogx", "application/ogg"},
{".otf", "font/otf"},
{".png", "image/png"},
{".pdf", "application/pdf"},
{".ppt", "application/vnd.ms-powerpoint"},
{".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
{".rar", "application/x-rar-compressed"},
{".rtf", "application/rtf"},
{".sh", "application/x-sh"},
{".svg", "image/svg+xml"},
{".swf", "application/x-shockwave-flash"},
{".tar", "application/x-tar"},
{".tif", "image/tiff"},
{".tiff", "image/tiff"},
{".ttf", "font/ttf"},
{".txt", "text/plain"},
{".vsd", "application/vnd.visio"},
{".wav", "audio/wav"},
{".weba", "audio/webm"},
{".webm", "video/webm"},
{".webp", "image/webp"},
{".woff", "font/woff"},
{".woff2", "font/woff2"},
{".xhtml", "application/xhtml+xml"},
{".xls", "application/vnd.ms-excel"},
{".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
{".xml", "application/xml"},
{".xul", "application/vnd.mozilla.xul+xml"},
{".zip", "application/zip"},
{".3gp", "video/3gpp"},
{".3g2", "video/3gpp2"},
{".7z", "application/x-7z-compressed"}};
class Util
{
public:
// 字符串分割函数,将src字符串按照sep字符进行分割,得到的各个字串放到arry中,最终返回字串的数量
static size_t Split(const string &src, const string &sep, vector<string> *arry)
{
size_t offset = 0;
while (offset < src.size())
{
size_t pos = src.find(sep, offset);
if (pos == string::npos)
{
// 没有找到特定的字符
// 将剩余的部分当作一个字串,放入arry中
if (pos == src.size())
break;
arry->push_back(src.substr(offset));
return arry->size();
}
if (pos == offset)
{
offset = pos + sep.size();
continue;
// 当前字串是一个空的,没有内容
}
arry->push_back(src.substr(offset, pos - offset));
offset = pos + sep.size();
}
return arry->size();
}
// 读取文件的所有内容,将读取的内容放到一个Buffer中
static bool ReadFile(const string &filename, string *buf)
{
ifstream ifs(filename, ios::binary);
if (ifs.is_open() == false)
{
printf("OPEN %s FILE FAILED!!", filename.c_str());
return false;
}
size_t fsize = 0;
ifs.seekg(0, ifs.end); // 跳转读写位置到末尾
fsize = ifs.tellg(); // 获取当前读写位置相对于起始位置的偏移量,从末尾偏移刚好就是文件大小
ifs.seekg(0, ifs.beg); // 跳转到起始位置
buf->resize(fsize); // 开辟文件大小的空间
ifs.read(&(*buf)[0], fsize);
if (ifs.good() == false)
{
lg(Warning, "read %s fail!", filename.c_str());
ifs.close();
return false;
}
ifs.close();
return true;
}
// 向文件写入数据
static bool WriteFile(const string &filename, const string &buf)
{
ofstream ofs(filename, ios::binary | ios::trunc);
if (ofs.is_open() == false)
{
lg(Warning, "open %s fail!", filename.c_str());
return false;
}
ofs.write(buf.c_str(), buf.size());
if (ofs.good() == false)
{
lg(Fatal, "WRITE %s FILE FAILED!", filename.c_str());
ofs.close();
return false;
}
ofs.close();
return true;
}
// URL编码,避免URL中资源路径与查询字符串中的特殊字符与HTTP请求中特殊字符产生歧义
static string UrlEncode(const string url, bool convert_space_to_plus)
{
string res;
for (auto &c : url)
{
if (c == '.' || c == '-' || c == '_' || c == '~' || isalnum(c))
{
res += c;
continue;
}
if (c == ' ' && convert_space_to_plus == true)
{
res += '+';
continue;
}
// 剩下的字符都是需要编码成为 %HH 格式
char tmp[4] = {0};
// snprintf 与 printf比较类似,都是格式化字符串,只不过一个是打印,一个是放到一块空间中
snprintf(tmp, 4, "%%%02X", c);
res += tmp;
}
return res;
}
static char HEXTOI(char c)
{
if (c >= '0' && c <= '9')
{
return c - '0';
}
else if (c >= 'a' && c <= 'z')
{
return c - 'a' + 10;
}
else if (c >= 'A' && c <= 'Z')
{
return c - 'A' + 10;
}
return -1;
}
static string UrlDecode(const string url, bool convert_plus_to_space)
{
string res;
for (int i = 0; i < url.size(); i++)
{
if (url[i] == '+' && convert_plus_to_space == true)
{
res += ' ';
continue;
}
if (url[i] == '%' && (i + 2) < url.size())
{
char v1 = HEXTOI(url[i + 1]);
char v2 = HEXTOI(url[i + 2]);
char v = v1 * 16 + v2;
res += v;
i += 2;
continue;
}
res += url[i];
}
return res;
}
// 响应状态码的描述信息获取
static string StatuDesc(int statu)
{
auto it = _statu_msg.find(statu);
if (it != _statu_msg.end())
{
return it->second;
}
return "Unknow";
}
// 根据文件后缀名获取文件mime
static string ExtMime(const string &filename)
{
// a.b.txt 先获取文件扩展名
size_t pos = filename.find_last_of('.');
if (pos == string::npos)
{
return "application/octet-stream";
}
// 根据扩展名,获取mime
string ext = filename.substr(pos);
auto it = _mime_msg.find(ext);
if (it == _mime_msg.end())
{
return "application/octet-stream";
}
return it->second;
}
// 判断一个文件是否是一个目录
static bool IsDirectory(const string &filename)
{
struct stat st;
int ret = stat(filename.c_str(), &st);
if (ret < 0)
{
return false;
}
return S_ISDIR(st.st_mode);
}
// 判断一个文件是否是一个普通文件
static bool IsRegular(const string &filename)
{
struct stat st;
int ret = stat(filename.c_str(), &st);
if (ret < 0)
{
return false;
}
return S_ISREG(st.st_mode);
}
// http请求的资源路径有效性判断
static bool ValidPath(const string &path)
{
// 思想:按照/进行路径分割,根据有多少子目录,计算目录深度,有多少层,深度不能小于0
vector<string> subdir;
Split(path, "/", &subdir);
int level = 0;
for (auto &dir : subdir)
{
if (dir == "..")
{
level--; // 任意一层走出相对根目录,就认为有问题
if (level < 0)
return false;
continue;
}
level++;
}
return true;
}
};
HTTPRequest模块
这个模块主要是对于HTTP的响应数据模块,用于进行业务处理后设置并保存HTTP响应数据的各项元素信息,最终会被按照HTTP协议响应格式组织成为响应信息发送给客户端
那在http请求信息模块当中,存储的就是http的请求信息要素,提供一些简单的功能性接口
对于请求信息要素中,主要包含有请求行:请求方法,URL,协议版本,对于正文部分来说,要包含有请求方法,资源路径,查询字符串,头部字段,正文部分,协议版本等,所要最终设计出的效果是,可以提供成员变量为共有,提供一些查询字符串,获取头部字段的单个查询和获取以及插入的功能,也要能够获取正文长度和判断长连接或者短连接
因此可以设计出该模块为
class HttpRequest
{
public:
HttpRequest() : _version("HTTP/1.1") {}
void ReSet()
{
_method.clear();
_path.clear();
_version = "HTTP/1.1";
_body.clear();
smatch match;
_matches.swap(match);
_headers.clear();
_params.clear();
}
// 插入头部字段
void SetHeader(const string &key, const string &val)
{
_headers.insert(make_pair(key, val));
}
// 判断是否存在指定头部字段
bool HasHeader(const string &key) const
{
auto it = _headers.find(key);
if (it == _headers.end())
{
return false;
}
return true;
}
// 获取指定头部字段的值
string GetHeader(const string &key) const
{
auto it = _headers.find(key);
if (it == _headers.end())
{
return "";
}
return it->second;
}
// 插入查询字符串
void SetParam(const string &key, const string &val)
{
_params.insert(make_pair(key, val));
}
// 判断是否有某个指定的查询字符串
bool HasParam(const string &key) const
{
auto it = _params.find(key);
if (it == _params.end())
{
return false;
}
return true;
}
// 获取指定的查询字符串
string GetParam(const string &key) const
{
auto it = _params.find(key);
if (it == _params.end())
{
return "";
}
return it->second;
}
// 获取正文长度
size_t ContentLength() const
{
// Content-Length: 1234\r\n
bool ret = HasHeader("Content-Length");
if (ret == false)
{
return 0;
}
string clen = GetHeader("Content-Length");
return stol(clen);
}
// 判断是否是短链接
bool Close() const
{
// 没有Connection字段,或者有Connection但是值是close,则都是短链接,否则就是长连接
if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
{
return false;
}
return true;
}
public:
string _method; // 请求方法
string _path; // 资源路径
string _version; // 协议版本
string _body; // 请求正文
smatch _matches; // 资源路径的正则提取数据
unordered_map<string, string> _headers; // 头部字段
unordered_map<string, string> _params; // 查询字符串
};
HTTPResponse模块
对于Http的响应来说,需要存储的有响应的状态码,头部字段,响应正文,重定向信息,整体来说设计起来也比较简单
class HttpResponse
{
public:
HttpResponse() : _redirect_flag(false), _statu(200) {}
HttpResponse(int statu) : _redirect_flag(false), _statu(statu) {}
void ReSet()
{
_statu = 200;
_redirect_flag = false;
_body.clear();
_redirect_url.clear();
_headers.clear();
}
// 插入头部字段
void SetHeader(const string &key, const string &val)
{
_headers.insert(make_pair(key, val));
}
// 判断是否存在指定头部字段
bool HasHeader(const string &key)
{
auto it = _headers.find(key);
if (it == _headers.end())
{
return false;
}
return true;
}
// 获取指定头部字段的值
string GetHeader(const string &key)
{
auto it = _headers.find(key);
if (it == _headers.end())
{
return "";
}
return it->second;
}
void SetContent(const string &body, const string &type = "text/html")
{
_body = body;
SetHeader("Content-Type", type);
}
void SetRedirect(const string &url, int statu = 302)
{
_statu = statu;
_redirect_flag = true;
_redirect_url = url;
}
// 判断是否是短链接
bool Close()
{
// 没有Connection字段,或者有Connection但是值是close,则都是短链接,否则就是长连接
if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
{
return false;
}
return true;
}
public:
int _statu;
bool _redirect_flag;
string _body;
string _redirect_url;
unordered_map<string, string> _headers;
};
HTTPContext模块
这个模块是对于HTTP请求接收的上下文模块,用来解决发送消息不完全的情况出现,也有用来记录Http请求的接收和处理的进度
存在这个模块的原因是,在进行接受数据的时候,可能会收到的不是一个完整的http请求的数据,那么就意味着请求的处理需要在多次受到数据后才能处理完成,因此每次处理的时候,就需要把处理进度存储起来,以便于下次从当前进度下开始处理
对于接受的信息来说,主要包含有
- 接收状态
接受请求行:当前处于接受并处理请求行的阶段,接收请求头部:表示请求头部的接收没有完毕,接收正文:表示的是正文没有接收完毕,接收数据完毕:表示的是数据接收完毕了,可以对于请求进行处理了,也可能会存在接受处理请求出错的信息
- 响应状态码
在请求的接收并处理中,可能会出现各种各样的问题,比如有请求解析出错,访问资源不对等问题,这些错误的状态码都是不一样的
HttpServer模块
这个模块是提供给使用者的http服务器模块,下面就对于HttpServer的原理进行解析
设计思路
对于这个模块来说,基本的逻辑思路是要在内部设计一个路由表,在这个表中会记录有各种需求,针对于某个特定的需求,执行对应的函数来进行业务的处理,当服务器收到了一个请求后,就会在请求路由表中去查询有没有对应请求的处理函数,如果有,就直接去执行对应的处理函数,说白了,就是不管是什么请求还是怎么来处理,都是让用户自己来进行决定的,服务器只是在进行收到请求后,再执行对应的函数就可以了
那这样做有什么好处?简单来说就是用户只需要来设置业务处理的函数,然后把请求和处理函数的映射关系放到服务器当中即可,而服务器本身只需要来进行接收数据即可,并进行解析,而对于如何执行函数只需要交给用户设置的业务处理函数即可
具体设计
那想要设计出这样的一个http的服务器,应该提供什么样的要素和功能呢?
首先肯定要包含一些常见请求的路由映射表,比如有对于GET、POST、PUT、DELETE请求的路由映射表,在这个路由映射表中记录的是对应请求方法和请求函数的映射关系,这个映射关系更多上更多的是对于功能请求上的处理
其次会包含一个静态资源的根目录,就是所谓的wwwroot,里面存储的是一些静态资源的处理,还应该有一个高性能的TCP服务器,具体可以使用一个Reactor模型的高并发服务器
接口设计
在接口设计上,要先明确整体的一套设计流程:
- 从Socket接收数据,放到接收缓冲区中
- 调用OnMessage回调函数进行业务处理
- 对于请求进行路由查找,找到对应请求的处理方法
- 进行请求的路由查找,如果是进行静态资源的请求,那么就来把这些数据读取出来,然后放到HttpResponse当中,如果是功能性请求,那么就从路由表中进行函数的执行,然后放到Response当中去即可
- 对于上述的处理结束之后,就有了一个Response的对象,然后再组织成Http格式进行响应,进行发送即可
#pragma once
#include <iostream>
#include <functional>
#include <string>
#include "Http.hpp"
#include "TcpServer.hpp"
#include "Log.hpp"
using namespace std;
const int default_timeout = 10;
class HttpServer
{
using Handler = function<void(const HttpRequest &, HttpResponse *)>;
using Handlers = vector<pair<regex, Handler>>;
public:
HttpServer(int port, int timeout = default_timeout) : _server(port)
{
_server.EnableInactiveRelease(timeout);
_server.SetConnectedCallback(bind(&HttpServer::OnConnected, this, placeholders::_1));
_server.SetMessageCallback(bind(&HttpServer::OnMessage, this, placeholders::_1, placeholders::_2));
}
void SetBaseDir(const string &path)
{
assert(Util::IsDirectory(path) == true);
_basedir = path;
}
/*设置/添加,请求(请求的正则表达)与处理函数的映射关系*/
void Get(const string &pattern, const Handler &handler)
{
_get_route.push_back(make_pair(regex(pattern), handler));
}
void Post(const string &pattern, const Handler &handler)
{
_post_route.push_back(make_pair(regex(pattern), handler));
}
void Put(const string &pattern, const Handler &handler)
{
_put_route.push_back(make_pair(regex(pattern), handler));
}
void Delete(const string &pattern, const Handler &handler)
{
_delete_route.push_back(make_pair(regex(pattern), handler));
}
void SetThreadCount(int count)
{
_server.SetThreadCount(count);
}
void Listen()
{
_server.Start();
}
private:
void ErrorHandler(const HttpRequest &req, HttpResponse *rsp)
{
// 1. 组织一个错误展示页面
string body;
body += "<html>";
body += "<head>";
body += "<meta http-equiv='Content-Type' content='text/html;charset=utf-8'>";
body += "</head>";
body += "<body>";
body += "<h1>";
body += to_string(rsp->_statu);
body += " ";
body += Util::StatuDesc(rsp->_statu);
body += "</h1>";
body += "</body>";
body += "</html>";
// 2. 将页面数据,当作响应正文,放入rsp中
rsp->SetContent(body, "text/html");
}
// 将HttpResponse中的要素按照http协议格式进行组织,发送
void WriteReponse(const PtrConnection &conn, const HttpRequest &req, HttpResponse &rsp)
{
// 1. 先完善头部字段
if (req.Close() == true)
{
rsp.SetHeader("Connection", "close");
}
else
{
rsp.SetHeader("Connection", "keep-alive");
}
if (rsp._body.empty() == false && rsp.HasHeader("Content-Length") == false)
{
rsp.SetHeader("Content-Length", to_string(rsp._body.size()));
}
if (rsp._body.empty() == false && rsp.HasHeader("Content-Type") == false)
{
rsp.SetHeader("Content-Type", "application/octet-stream");
}
if (rsp._redirect_flag == true)
{
rsp.SetHeader("Location", rsp._redirect_url);
}
// 2. 将rsp中的要素,按照http协议格式进行组织
stringstream rsp_str;
rsp_str << req._version << " " << to_string(rsp._statu) << " " << Util::StatuDesc(rsp._statu) << "\r\n";
for (auto &head : rsp._headers)
{
rsp_str << head.first << ": " << head.second << "\r\n";
}
rsp_str << "\r\n";
rsp_str << rsp._body;
// 3. 发送数据
conn->Send(rsp_str.str().c_str(), rsp_str.str().size());
}
bool IsFileHandler(const HttpRequest &req)
{
// 1. 必须设置了静态资源根目录
if (_basedir.empty())
{
return false;
}
// 2. 请求方法,必须是GET / HEAD请求方法
if (req._method != "GET" && req._method != "HEAD")
{
return false;
}
// 3. 请求的资源路径必须是一个合法路径
if (Util::ValidPath(req._path) == false)
{
return false;
}
// 4. 请求的资源必须存在,且是一个普通文件
// 有一种请求比较特殊 -- 目录:/, /image/, 这种情况给后边默认追加一个 index.html
// index.html /image/a.png
// 不要忘了前缀的相对根目录,也就是将请求路径转换为实际存在的路径 /image/a.png -> ./wwwroot/image/a.png
string req_path = _basedir + req._path; // 为了避免直接修改请求的资源路径,因此定义一个临时对象
if (req._path.back() == '/')
{
req_path += "index.html";
}
if (Util::IsRegular(req_path) == false)
{
return false;
}
return true;
}
// 静态资源的请求处理 --- 将静态资源文件的数据读取出来,放到rsp的_body中, 并设置mime
void FileHandler(const HttpRequest &req, HttpResponse *rsp)
{
string req_path = _basedir + req._path;
if (req._path.back() == '/')
{
req_path += "index.html";
}
bool ret = Util::ReadFile(req_path, &rsp->_body);
if (ret == false)
{
return;
}
string mime = Util::ExtMime(req_path);
rsp->SetHeader("Content-Type", mime);
return;
}
// 功能性请求的分类处理
void Dispatcher(HttpRequest &req, HttpResponse *rsp, Handlers &handlers)
{
// 在对应请求方法的路由表中,查找是否含有对应资源请求的处理函数,有则调用,没有则发挥404
// 思想:路由表存储的时键值对 -- 正则表达式 & 处理函数
// 使用正则表达式,对请求的资源路径进行正则匹配,匹配成功就使用对应函数进行处理
// /numbers/(\d+) /numbers/12345
for (auto &handler : handlers)
{
const regex &re = handler.first;
const Handler &functor = handler.second;
bool ret = regex_match(req._path, req._matches, re);
if (ret == false)
{
continue;
}
return functor(req, rsp); // 传入请求信息,和空的rsp,执行处理函数
}
rsp->_statu = 404;
}
void Route(HttpRequest &req, HttpResponse *rsp)
{
// 1. 对请求进行分辨,是一个静态资源请求,还是一个功能性请求
// 静态资源请求,则进行静态资源的处理
// 功能性请求,则需要通过几个请求路由表来确定是否有处理函数
// 既不是静态资源请求,也没有设置对应的功能性请求处理函数,就返回405
if (IsFileHandler(req) == true)
{
// 是一个静态资源请求, 则进行静态资源请求的处理
return FileHandler(req, rsp);
}
if (req._method == "GET" || req._method == "HEAD")
{
return Dispatcher(req, rsp, _get_route);
}
else if (req._method == "POST")
{
return Dispatcher(req, rsp, _post_route);
}
else if (req._method == "PUT")
{
return Dispatcher(req, rsp, _put_route);
}
else if (req._method == "DELETE")
{
return Dispatcher(req, rsp, _delete_route);
}
rsp->_statu = 405; // Method Not Allowed
return;
}
// 设置上下文
void OnConnected(const PtrConnection &conn)
{
conn->SetContext(HttpContext());
lg(Info, "NEW CONNECTION %p", conn.get());
}
// 缓冲区数据解析+处理
void OnMessage(const PtrConnection &conn, Buffer *buffer)
{
while (buffer->ReadableSize() > 0)
{
// 1. 获取上下文
HttpContext *context = conn->GetContext()->get<HttpContext>();
// 2. 通过上下文对缓冲区数据进行解析,得到HttpRequest对象
// 1. 如果缓冲区的数据解析出错,就直接回复出错响应
// 2. 如果解析正常,且请求已经获取完毕,才开始去进行处理
context->RecvHttpRequest(buffer);
HttpRequest &req = context->Request();
HttpResponse rsp(context->RespStatu());
if (context->RespStatu() >= 400)
{
// 进行错误响应,关闭连接
ErrorHandler(req, &rsp); // 填充一个错误显示页面数据到rsp中
WriteReponse(conn, req, rsp); // 组织响应发送给客户端
context->ReSet();
buffer->MoveReadOffset(buffer->ReadableSize()); // 出错了就把缓冲区数据清空
conn->Shutdown(); // 关闭连接
return;
}
if (context->RecvStatu() != RECV_HTTP_OVER)
{
// 当前请求还没有接收完整,则退出,等新数据到来再重新继续处理
return;
}
// 3. 请求路由 + 业务处理
Route(req, &rsp);
// 4. 对HttpResponse进行组织发送
WriteReponse(conn, req, rsp);
// 5. 重置上下文
context->ReSet();
// 6. 根据长短连接判断是否关闭连接或者继续处理
if (rsp.Close() == true)
conn->Shutdown(); // 短链接则直接关闭
}
return;
}
private:
Handlers _get_route;
Handlers _post_route;
Handlers _put_route;
Handlers _delete_route;
string _basedir; // 静态资源根目录
TcpServer _server;
};