从零构建HTTP服务器：深入理解HTTP协议与实现（超详细，收藏这一篇就够了）

从零构建HTTP服务器：深入理解HTTP协议与实现

引言

在当今互联网时代，HTTP协议作为万维网的基础协议，承载着几乎所有的网络应用数据交换。无论是浏览网页、使用移动应用还是进行API调用，都离不开HTTP协议的支持。本文将深入探讨HTTP协议的原理，并从零开始构建一个完整的HTTP服务器，通过丰富的代码示例和详细的理论讲解，帮助读者全面掌握HTTP服务器的设计与实现。

本文内容将涵盖网络编程的基础、HTTP协议的详细解析、服务器架构设计、以及实际代码实现，总字数超过10000字，包含大量可运行的代码示例，适合有一定C/C++基础并希望深入了解网络编程和HTTP协议的开发者阅读。

一、服务器设计流程

1.1 网络模型基础

在深入HTTP服务器设计之前，我们需要理解计算机网络的分层模型。OSI（开放系统互连）七层模型是网络通信的理论基础，它将网络通信划分为七个层次：

1. 物理层：负责比特流在物理介质上的传输
2. 数据链路层：负责节点到节点的数据传输
3. 网络层：负责数据包的路由和转发
4. 传输层：负责端到端的可靠数据传输
5. 会话层：负责建立、管理和终止会话
6. 表示层：负责数据格式转换、加密解密
7. 应用层：负责应用程序间的通信

在实际网络编程中，我们主要关注传输层及以上层次。特别是传输层的TCP/UDP协议，为上层应用提供了可靠的通信基础。

1.2 TCP服务器编程模型

HTTP协议通常运行在TCP之上，因此HTTP服务器的核心是一个TCP服务器。一个基本的TCP服务器需要经历以下步骤：

// TCP服务器基本流程伪代码intmain(){// 1. 创建socketintserver_fd=socket(AF_INET,SOCK_STREAM,0);// 2. 绑定地址和端口bind(server_fd,(structsockaddr*)&address,sizeof(address));// 3. 监听连接listen(server_fd,backlog);while(1){// 4. 接受客户端连接intclient_fd=accept(server_fd,(structsockaddr*)&client_addr,&addr_len);// 5. 处理客户端请求handle_request(client_fd);// 6. 关闭连接close(client_fd);}// 7. 关闭服务器close(server_fd);return0;}

1.3 Reactor模式与事件驱动

现代高性能HTTP服务器通常采用事件驱动模型，如Reactor模式。这种模式能够高效地处理大量并发连接，是Nginx、Node.js等高性能服务器的核心架构。

Reactor模式核心组件：

1. 事件分发器（Dispatcher）：负责等待事件发生
2. 事件处理器（EventHandler）：定义处理事件的接口
3. 具体事件处理器（ConcreteEventHandler）：实现具体的事件处理逻辑
4. 事件源（Handle）：产生事件的来源，如socket

下面是一个简单的Reactor模式实现框架：

#include<sys/epoll.h>#include<sys/socket.h>#include<netinet/in.h>#include<arpa/inet.h>#include<fcntl.h>#include<unistd.h>#include<stdio.h>#include<errno.h>#include<string.h>#include<stdlib.h>#include<vector>#include<map>#include<functional>#defineMAX_EVENTS1024#defineBUFFER_SIZE4096// 事件类型枚举enumEventType{READ_EVENT=1,WRITE_EVENT=2,ERROR_EVENT=4};// 事件处理器基类classEventHandler{public:virtual~EventHandler(){}virtualvoidhandle_event(intfd,uint32_tevents)=0;virtualintget_handle()const=0;};// Reactor核心类classReactor{private:intepoll_fd;boolrunning;std::map<int,EventHandler*>handlers;public:Reactor():epoll_fd(-1),running(false){}~Reactor(){if(epoll_fd>=0)close(epoll_fd);}// 初始化Reactorboolinit(){epoll_fd=epoll_create1(0);if(epoll_fd<0){perror("epoll_create1 failed");returnfalse;}returntrue;}// 注册事件处理器boolregister_handler(EventHandler*handler,uint32_tevents){intfd=handler->get_handle();structepoll_eventev;ev.events=events;ev.data.ptr=handler;if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,fd,&ev)<0){perror("epoll_ctl add failed");returnfalse;}handlers[fd]=handler;returntrue;}// 移除事件处理器boolremove_handler(EventHandler*handler){intfd=handler->get_handle();if(epoll_ctl(epoll_fd,EPOLL_CTL_DEL,fd,NULL)<0){perror("epoll_ctl del failed");returnfalse;}handlers.erase(fd);returntrue;}// 事件循环voidevent_loop(inttimeout=-1){running=true;structepoll_eventevents[MAX_EVENTS];while(running){intnfds=epoll_wait(epoll_fd,events,MAX_EVENTS,timeout);if(nfds<0){if(errno==EINTR)continue;perror("epoll_wait failed");break;}for(inti=0;i<nfds;i++){EventHandler*handler=static_cast<EventHandler*>(events[i].data.ptr);if(handler){handler->handle_event(handler->get_handle(),events[i].events);}}}}// 停止事件循环voidstop(){running=false;}};// 连接项，管理单个客户端连接classConnection:publicEventHandler{private:intfd;Reactor*reactor;std::string in_buffer;std::string out_buffer;structsockaddr_inclient_addr;// HTTP请求解析状态enumParseState{PARSE_REQUEST_LINE,PARSE_HEADERS,PARSE_BODY,PARSE_COMPLETE};ParseState parse_state;std::map<std::string,std::string>headers;std::string method;std::string url;std::string version;size_t content_length;public:Connection(intfd,Reactor*reactor,conststructsockaddr_in&addr):fd(fd),reactor(reactor),client_addr(addr),parse_state(PARSE_REQUEST_LINE),content_length(0){// 设置非阻塞intflags=fcntl(fd,F_GETFL,0);fcntl(fd,F_SETFL,flags|O_NONBLOCK);}~Connection(){if(fd>=0)close(fd);}intget_handle()constoverride{returnfd;}voidhandle_event(intfd,uint32_tevents)override{if(events&EPOLLIN){handle_read();}if(events&EPOLLOUT){handle_write();}if(events&(EPOLLERR|EPOLLHUP)){handle_error();}}private:voidhandle_read(){charbuffer[BUFFER_SIZE];ssize_t n=read(fd,buffer,sizeof(buffer)-1);if(n>0){buffer[n]='\0';in_buffer.append(buffer,n);parse_http_request();}elseif(n==0){// 客户端关闭连接cleanup();}else{if(errno!=EAGAIN&&errno!=EWOULDBLOCK){perror("read error");cleanup();}}}voidhandle_write(){if(!out_buffer.empty()){ssize_t n=write(fd,out_buffer.data(),out_buffer.size());if(n>0){out_buffer.erase(0,n);}else{if(errno!=EAGAIN&&errno!=EWOULDBLOCK){perror("write error");cleanup();}}}// 如果没有数据要发送，取消写事件监听if(out_buffer.empty()){update_event_monitoring(EPOLLIN);}}voidhandle_error(){cleanup();}voidcleanup(){reactor->remove_handler(this);deletethis;}voidupdate_event_monitoring(uint32_tevents){structepoll_eventev;ev.events=events;ev.data.ptr=this;epoll_ctl(reactor->get_handle(),EPOLL_CTL_MOD,fd,&ev);}voidparse_http_request(){// HTTP请求解析实现将在后面详细介绍}voidsend_response(){// HTTP响应发送实现将在后面详细介绍}};// HTTP服务器类classHttpServer{private:intserver_fd;Reactor reactor;structsockaddr_inserver_addr;public:HttpServer(intport=8080){memset(&server_addr,0,sizeof(server_addr));server_addr.sin_family=AF_INET;server_addr.sin_addr.s_addr=htonl(INADDR_ANY);server_addr.sin_port=htons(port);}~HttpServer(){if(server_fd>=0)close(server_fd);}boolinit(){// 创建socketserver_fd=socket(AF_INET,SOCK_STREAM,0);if(server_fd<0){perror("socket creation failed");returnfalse;}// 设置socket选项，允许地址重用intopt=1;if(setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt))<0){perror("setsockopt failed");returnfalse;}// 绑定地址if(bind(server_fd,(structsockaddr*)&server_addr,sizeof(server_addr))<0){perror("bind failed");returnfalse;}// 监听连接if(listen(server_fd,SOMAXCONN)<0){perror("listen failed");returnfalse;}// 设置非阻塞intflags=fcntl(server_fd,F_GETFL,0);fcntl(server_fd,F_SETFL,flags|O_NONBLOCK);// 初始化Reactorif(!reactor.init()){returnfalse;}returntrue;}voidstart(){// 创建监听socket的事件处理器classAcceptHandler:publicEventHandler{private:HttpServer*server;public:AcceptHandler(HttpServer*s):server(s){}intget_handle()constoverride{returnserver->server_fd;}voidhandle_event(intfd,uint32_tevents)override{if(events&EPOLLIN){server->handle_accept();}}};// 注册AcceptHandler到ReactorAcceptHandler*handler=newAcceptHandler(this);reactor.register_handler(handler,EPOLLIN);printf("HTTP Server started on port %d\n",ntohs(server_addr.sin_port));// 开始事件循环reactor.event_loop();}private:voidhandle_accept(){structsockaddr_inclient_addr;socklen_t addr_len=sizeof(client_addr);while(true){intclient_fd=accept(server_fd,(structsockaddr*)&client_addr,&addr_len);if(client_fd<0){if(errno==EAGAIN||errno==EWOULDBLOCK){// 没有更多连接break;}else{perror("accept failed");break;}}// 创建新连接并注册到ReactorConnection*conn=newConnection(client_fd,&reactor,client_addr);reactor.register_handler(conn,EPOLLIN|EPOLLET);// 边沿触发模式printf("New connection from %s:%d\n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));}}};intmain(){HttpServerserver(8080);if(!server.init()){fprintf(stderr,"Server initialization failed\n");return1;}server.start();return0;}

1.4 多线程与多进程模型

除了事件驱动模型，HTTP服务器还可以采用多线程或多进程模型来处理并发连接。每种模型都有其优缺点：

多进程模型（Pre-forking）

#include<stdio.h>#include<stdlib.h>#include<string.h>#include<unistd.h>#include<sys/socket.h>#include<netinet/in.h>#include<sys/wait.h>#include<signal.h>#defineMAX_CHILDREN10#definePORT8080// 子进程处理函数voidchild_process(intserver_fd){while(1){structsockaddr_inclient_addr;socklen_taddr_len=sizeof(client_addr);intclient_fd=accept(server_fd,(structsockaddr*)&client_addr,&addr_len);if(client_fd<0){perror("accept failed");continue;}// 处理HTTP请求handle_http_request(client_fd);close(client_fd);}}intmain(){intserver_fd;structsockaddr_inserver_addr;// 创建socketserver_fd=socket(AF_INET,SOCK_STREAM,0);// 设置地址重用intopt=1;setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));// 绑定地址server_addr.sin_family=AF_INET;server_addr.sin_addr.s_addr=INADDR_ANY;server_addr.sin_port=htons(PORT);bind(server_fd,(structsockaddr*)&server_addr,sizeof(server_addr));// 监听listen(server_fd,SOMAXCONN);printf("Master process started, creating child processes...\n");// 创建子进程for(inti=0;i<MAX_CHILDREN;i++){pid_tpid=fork();if(pid==0){// 子进程printf("Child process %d started\n",getpid());child_process(server_fd);exit(0);}elseif(pid<0){perror("fork failed");}}// 父进程等待子进程for(inti=0;i<MAX_CHILDREN;i++){wait(NULL);}close(server_fd);return0;}

线程池模型

#include<iostream>#include<vector>#include<queue>#include<thread>#include<mutex>#include<condition_variable>#include<functional>#include<atomic>classThreadPool{private:std::vector<std::thread>workers;std::queue<std::function<void()>>tasks;std::mutex queue_mutex;std::condition_variable condition;std::atomic<bool>stop;public:ThreadPool(size_t threads):stop(false){for(size_t i=0;i<threads;++i){workers.emplace_back([this]{while(true){std::function<void()>task;{std::unique_lock<std::mutex>lock(this->queue_mutex);this->condition.wait(lock,[this]{returnthis->stop||!this->tasks.empty();});if(this->stop&&this->tasks.empty()){return;}task=std::move(this->tasks.front());this->tasks.pop();}task();}});}}template<classF>voidenqueue(F&&f){{std::unique_lock<std::mutex>lock(queue_mutex);tasks.emplace(std::forward<F>(f));}condition.notify_one();}~ThreadPool(){{std::unique_lock<std::mutex>lock(queue_mutex);stop=true;}condition.notify_all();for(std::thread&worker:workers){worker.join();}}};// 使用线程池的HTTP服务器classThreadedHttpServer{private:intserver_fd;ThreadPool pool;public:ThreadedHttpServer(intport,size_t thread_count=4):pool(thread_count){server_fd=socket(AF_INET,SOCK_STREAM,0);structsockaddr_inserver_addr;server_addr.sin_family=AF_INET;server_addr.sin_addr.s_addr=INADDR_ANY;server_addr.sin_port=htons(port);bind(server_fd,(structsockaddr*)&server_addr,sizeof(server_addr));listen(server_fd,SOMAXCONN);}voidstart(){printf("Threaded HTTP server started\n");while(true){structsockaddr_inclient_addr;socklen_t addr_len=sizeof(client_addr);intclient_fd=accept(server_fd,(structsockaddr*)&client_addr,&addr_len);if(client_fd<0){perror("accept failed");continue;}// 将任务提交到线程池pool.enqueue([this,client_fd,client_addr]{handle_http_request(client_fd);close(client_fd);});}}private:voidhandle_http_request(intclient_fd){// HTTP请求处理逻辑}};

1.5 服务器架构设计考虑

设计一个高性能HTTP服务器需要考虑多个方面：

1. 并发模型选择：事件驱动 vs 多线程 vs 多进程
2. I/O多路复用技术：select/poll vs epoll vs kqueue
3. 内存管理：缓冲区设计、内存池
4. 连接管理：连接池、超时控制
5. 负载均衡：多进程间负载均衡
6. 日志系统：请求日志、错误日志
7. 配置管理：运行时配置加载
8. 安全考虑：DDoS防护、输入验证

二、HTTP协议详解

2.1 URL网址结构

URL（Uniform Resource Locator）统一资源定位符，是互联网上标准资源的地址。一个完整的URL包含以下部分：

https://www.example.com:8080/path/to/resource?query=value#fragment └─┬─┘ └──────┬──────┘ └┬─┘ └───────┬───────┘ └───┬───┘ └──┬──┘ 协议 主机名 端口 路径 查询参数 片段

让我们详细解析每个部分：

#include<string>#include<map>#include<sstream>#include<algorithm>classURL{private:std::string scheme;// http, https, ftp等std::string host;// 主机名或IP地址intport;// 端口号std::string path;// 资源路径std::map<std::string,std::string>query_params;// 查询参数std::string fragment;// 片段标识public:// 解析URLboolparse(conststd::string&url_str){std::string remaining=url_str;// 解析协议size_t scheme_end=remaining.find("://");if(scheme_end!=std::string::npos){scheme=remaining.substr(0,scheme_end);remaining=remaining.substr(scheme_end+3);}// 解析主机和端口size_t host_end=remaining.find_first_of("/?#");std::string host_port;if(host_end!=std::string::npos){host_port=remaining.substr(0,host_end);remaining=remaining.substr(host_end);}else{host_port=remaining;remaining="";}// 分离主机和端口size_t port_start=host_port.find(':');if(port_start!=std::string::npos){host=host_port.substr(0,port_start);std::string port_str=host_port.substr(port_start+1);port=std::stoi(port_str);}else{host=host_port;// 默认端口if(scheme=="https")port=443;elseif(scheme=="http")port=80;elseport=80;}// 解析路径、查询参数和片段parse_path_query_fragment(remaining);returntrue;}voidparse_path_query_fragment(conststd::string&str){std::string remaining=str;// 解析片段size_t fragment_start=remaining.find('#');if(fragment_start!=std::string::npos){fragment=remaining.substr(fragment_start+1);remaining=remaining.substr(0,fragment_start);}// 解析查询参数size_t query_start=remaining.find('?');if(query_start!=std::string::npos){path=remaining.substr(0,query_start);std::string query_str=remaining.substr(query_start+1);parse_query_params(query_str);}else{path=remaining;}// 如果路径为空，设置为根路径if(path.empty()){path="/";}}voidparse_query_params(conststd::string&query_str){std::stringstreamss(query_str);std::string pair;while(std::getline(ss,pair,'&')){size_t eq_pos=pair.find('=');if(eq_pos!=std::string::npos){std::string key=pair.substr(0,eq_pos);std::string value=pair.substr(eq_pos+1);// URL解码（简化版）key=url_decode(key);value=url_decode(value);query_params[key]=value;}}}std::stringurl_decode(conststd::string&encoded){std::string decoded;decoded.reserve(encoded.size());for(size_t i=0;i<encoded.size();++i){if(encoded[i]=='%'&&i+2<encoded.size()){std::string hex=encoded.substr(i+1,2);charch=static_cast<char>(std::stoi(hex,nullptr,16));decoded.push_back(ch);i+=2;}elseif(encoded[i]=='+'){decoded.push_back(' ');}else{decoded.push_back(encoded[i]);}}returndecoded;}// Getter方法std::stringget_scheme()const{returnscheme;}std::stringget_host()const{returnhost;}intget_port()const{returnport;}std::stringget_path()const{returnpath;}std::map<std::string,std::string>get_query_params()const{returnquery_params;}std::stringget_fragment()const{returnfragment;}// 重新构建URLstd::stringbuild()const{std::stringstream ss;if(!scheme.empty()){ss<<scheme<<"://";}ss<<host;if((scheme=="http"&&port!=80)||(scheme=="https"&&port!=443)){ss<<":"<<port;}ss<<path;if(!query_params.empty()){ss<<"?";boolfirst=true;for(constauto&param:query_params){if(!first)ss<<"&";ss<<param.first<<"="<<param.second;first=false;}}if(!fragment.empty()){ss<<"#"<<fragment;}returnss.str();}};// 使用示例voidurl_example(){URL url;url.parse("https://www.example.com:8080/api/v1/users?name=john&age=25#section1");printf("Scheme: %s\n",url.get_scheme().c_str());printf("Host: %s\n",url.get_host().c_str());printf("Port: %d\n",url.get_port());printf("Path: %s\n",url.get_path().c_str());autoparams=url.get_query_params();for(constauto&param:params){printf("Query: %s = %s\n",param.first.c_str(),param.second.c_str());}printf("Fragment: %s\n",url.get_fragment().c_str());printf("Rebuilt URL: %s\n",url.build().c_str());}

2.2 HTTP请求（Request）

HTTP请求由客户端发送到服务器，包含请求行、请求头和请求体三部分。

2.2.1 请求行结构

请求行包含三个部分：请求方法、请求URI和HTTP版本。

GET /index.html HTTP/1.1

2.2.2 完整的HTTP请求类实现

#include<string>#include<map>#include<vector>#include<sstream>#include<algorithm>#include<cctype>classHttpRequest{private:std::string method;// 请求方法：GET, POST等std::string uri;// 请求URIstd::string version;// HTTP版本std::map<std::string,std::string>headers;// 请求头std::string body;// 请求体std::map<std::string,std::string>query_params;// 查询参数std::map<std::string,std::string>form_data;// POST表单数据// 解析状态enumParseState{PARSE_REQUEST_LINE,PARSE_HEADERS,PARSE_BODY,PARSE_COMPLETE};ParseState parse_state;public:HttpRequest():parse_state(PARSE_REQUEST_LINE){}// 解析HTTP请求boolparse(conststd::string&raw_request){std::istringstreamstream(raw_request);std::string line;// 解析请求行if(parse_state==PARSE_REQUEST_LINE){if(!std::getline(stream,line)){returnfalse;}if(!parse_request_line(line)){returnfalse;}parse_state=PARSE_HEADERS;}// 解析请求头if(parse_state==PARSE_HEADERS){while(std::getline(stream,line)){// 去除末尾的\rif(!line.empty()&&line.back()=='\r'){line.pop_back();}// 空行表示头部结束if(line.empty()){parse_state=PARSE_BODY;break;}if(!parse_header_line(line)){returnfalse;}}}// 解析请求体if(parse_state==PARSE_BODY){// 获取剩余内容作为请求体std::streampos body_start=stream.tellg();stream.seekg(0,std::ios::end);std::streampos body_end=stream.tellg();stream.seekg(body_start);size_t body_length=body_end-body_start;if(body_length>0){std::vector<char>buffer(body_length);stream.read(buffer.data(),body_length);body.assign(buffer.data(),body_length);// 根据Content-Type解析请求体parse_body();}parse_state=PARSE_COMPLETE;}returntrue;}private:boolparse_request_line(conststd::string&line){std::istringstreamline_stream(line);if(!(line_stream>>method>>uri>>version)){returnfalse;}// 解析查询参数size_t query_pos=uri.find('?');if(query_pos!=std::string::npos){std::string query_str=uri.substr(query_pos+1);uri=uri.substr(0,query_pos);parse_query_params(query_str);}returntrue;}boolparse_header_line(conststd::string&line){size_t colon_pos=line.find(':');if(colon_pos==std::string::npos){returnfalse;}std::string key=line.substr(0,colon_pos);std::string value=line.substr(colon_pos+1);// 去除首尾空白字符trim(key);trim(value);headers[key]=value;returntrue;}voidparse_query_params(conststd::string&query_str){std::stringstreamss(query_str);std::string pair;while(std::getline(ss,pair,'&')){size_t eq_pos=pair.find('=');if(eq_pos!=std::string::npos){std::string key=pair.substr(0,eq_pos);std::string value=pair.substr(eq_pos+1);// URL解码key=url_decode(key);value=url_decode(value);query_params[key]=value;}}}voidparse_body(){autocontent_type_it=headers.find("Content-Type");if(content_type_it!=headers.end()){std::string content_type=content_type_it->second;if(content_type.find("application/x-www-form-urlencoded")!=std::string::npos){parse_form_urlencoded();}elseif(content_type.find("multipart/form-data")!=std::string::npos){parse_multipart_form_data();}elseif(content_type.find("application/json")!=std::string::npos){// JSON解析可以在这里实现}}elseif(method=="POST"){// 默认解析为表单数据parse_form_urlencoded();}}voidparse_form_urlencoded(){parse_query_params(body);// 复用查询参数解析逻辑form_data=query_params;}voidparse_multipart_form_data(){autocontent_type_it=headers.find("Content-Type");if(content_type_it==headers.end())return;std::string content_type=content_type_it->second;// 提取boundarysize_t boundary_pos=content_type.find("boundary=");if(boundary_pos==std::string::npos)return;std::string boundary=content_type.substr(boundary_pos+9);std::string delimiter="--"+boundary;std::string end_delimiter=delimiter+"--";size_t pos=0;// 跳过第一个delimiterpos=body.find(delimiter,pos);if(pos==std::string::npos)return;pos+=delimiter.length();while(pos<body.length()){// 跳过CRLFif(body.substr(pos,2)=="\r\n"){pos+=2;}// 检查是否到达结束delimiterif(body.substr(pos,end_delimiter.length())==end_delimiter){break;}// 解析part头部std::map<std::string,std::string>part_headers;while(pos<body.length()){size_t line_end=body.find("\r\n",pos);if(line_end==std::string::npos)break;std::string line=body.substr(pos,line_end-pos);pos=line_end+2;// 空行表示头部结束if(line.empty()){break;}size_t colon_pos=line.find(':');if(colon_pos!=std::string::npos){std::string key=line.substr(0,colon_pos);std::string value=line.substr(colon_pos+1);trim(key);trim(value);part_headers[key]=value;}}// 查找part内容结束位置size_t part_end=body.find("\r\n"+delimiter,pos);if(part_end==std::string::npos)break;std::string part_content=body.substr(pos,part_end-pos);pos=part_end+2;// 解析part内容autocontent_disposition_it=part_headers.find("Content-Disposition");if(content_disposition_it!=part_headers.end()){std::string disposition=content_disposition_it->second;// 提取namesize_t name_pos=disposition.find("name=\"");if(name_pos!=std::string::npos){name_pos+=6;size_t name_end=disposition.find("\"",name_pos);if(name_end!=std::string::npos){std::string name=disposition.substr(name_pos,name_end-name_pos);form_data[name]=part_content;}}}}}// 辅助函数voidtrim(std::string&str){// 去除左侧空白str.erase(str.begin(),std::find_if(str.begin(),str.end(),[](intch){return!std::isspace(ch);}));// 去除右侧空白str.erase(std::find_if(str.rbegin(),str.rend(),[](intch){return!std::isspace(ch);}).base(),str.end());}std::stringurl_decode(conststd::string&encoded){std::string decoded;decoded.reserve(encoded.size());for(size_t i=0;i<encoded.size();++i){if(encoded[i]=='%'&&i+2<encoded.size()){std::string hex=encoded.substr(i+1,2);charch=static_cast<char>(std::stoi(hex,nullptr,16));decoded.push_back(ch);i+=2;}elseif(encoded[i]=='+'){decoded.push_back(' ');}else{decoded.push_back(encoded[i]);}}returndecoded;}public:// Getter方法std::stringget_method()const{returnmethod;}std::stringget_uri()const{returnuri;}std::stringget_version()const{returnversion;}std::stringget_body()const{returnbody;}std::stringget_header(conststd::string&key)const{autoit=headers.find(key);returnit!=headers.end()?it->second:"";}conststd::map<std::string,std::string>&get_headers()const{returnheaders;}std::stringget_query_param(conststd::string&key)const{autoit=query_params.find(key);returnit!=query_params.end()?it->second:"";}conststd::map<std::string,std::string>&get_query_params()const{returnquery_params;}std::stringget_form_data(conststd::string&key)const{autoit=form_data.find(key);returnit!=form_data.end()?it->second:"";}conststd::map<std::string,std::string>&get_form_data()const{returnform_data;}// 判断是否keep-aliveboolis_keep_alive()const{std::string connection=get_header("Connection");if(version=="HTTP/1.1"){returnconnection!="close";}else{returnconnection=="keep-alive";}}// 获取内容长度size_tget_content_length()const{std::string length_str=get_header("Content-Length");if(!length_str.empty()){returnstd::stoul(length_str);}return0;}};

2.3 HTTP响应（Response）

HTTP响应是服务器对客户端请求的回复，包含状态行、响应头和响应体。

2.3.1 状态行结构

状态行包含三个部分：HTTP版本、状态码和状态描述。

HTTP/1.1 200 OK

2.3.2 完整的HTTP响应类实现

classHttpResponse{private:std::string version;// HTTP版本intstatus_code;// 状态码std::string status_message;// 状态描述std::map<std::string,std::string>headers;// 响应头std::string body;// 响应体public:HttpResponse():version("HTTP/1.1"),status_code(200),status_message("OK"){}// 设置状态voidset_status(intcode,conststd::string&message=""){status_code=code;if(!message.empty()){status_message=message;}else{// 默认状态描述switch(code){case200:status_message="OK";break;case201:status_message="Created";break;case204:status_message="No Content";break;case301:status_message="Moved Permanently";break;case302:status_message="Found";break;case304:status_message="Not Modified";break;case400:status_message="Bad Request";break;case401:status_message="Unauthorized";break;case403:status_message="Forbidden";break;case404:status_message="Not Found";break;case405:status_message="Method Not Allowed";break;case500:status_message="Internal Server Error";break;case502:status_message="Bad Gateway";break;case503:status_message="Service Unavailable";break;default:status_message="Unknown";break;}}}// 设置响应头voidset_header(conststd::string&key,conststd::string&value){headers[key]=value;}// 设置响应体voidset_body(conststd::string&content,conststd::string&content_type="text/html"){body=content;set_header("Content-Length",std::to_string(body.size()));set_header("Content-Type",content_type);}// 设置JSON响应体voidset_json_body(conststd::string&json){body=json;set_header("Content-Length",std::to_string(body.size()));set_header("Content-Type","application/json; charset=utf-8");}// 设置重定向voidset_redirect(conststd::string&location,intcode=302){set_status(code);set_header("Location",location);}// 构建完整响应字符串std::stringbuild()const{std::stringstream ss;// 状态行ss<<version<<" "<<status_code<<" "<<status_message<<"\r\n";// 响应头for(constauto&header:headers){ss<<header.first<<": "<<header.second<<"\r\n";}// 空行ss<<"\r\n";// 响应体ss<<body;returnss.str();}// 发送响应到socketboolsend(intsocket_fd)const{std::string response=build();ssize_t total_sent=0;ssize_t to_send=response.size();while(total_sent<to_send){ssize_t sent=write(socket_fd,response.c_str()+total_sent,to_send-total_sent);if(sent<0){if(errno==EAGAIN||errno==EWOULDBLOCK){// 非阻塞socket，稍后重试continue;}returnfalse;}total_sent+=sent;}returntrue;}// 静态方法：创建常见响应staticHttpResponsemake_ok_response(conststd::string&content="",conststd::string&content_type="text/html"){HttpResponse response;response.set_status(200);if(!content.empty()){response.set_body(content,content_type);}returnresponse;}staticHttpResponsemake_error_response(intcode,conststd::string&message=""){HttpResponse response;response.set_status(code);std::string error_page="<html><head><title>"+std::to_string(code)+" "+response.status_message+"</title></head><body><h1>"+std::to_string(code)+" "+response.status_message+"</h1>";if(!message.empty()){error_page+="<p>"+message+"</p>";}error_page+="</body></html>";response.set_body(error_page);returnresponse;}staticHttpResponsemake_json_response(conststd::string&json){HttpResponse response;response.set_status(200);response.set_json_body(json);returnresponse;}staticHttpResponsemake_redirect_response(conststd::string&location,intcode=302){HttpResponse response;response.set_redirect(location,code);returnresponse;}};

2.4 HTTP协议细节补充

2.4.1 HTTP状态码详解

HTTP状态码分为5类，每类有不同的含义：

classHttpStatus{public:// 信息性状态码 (1xx)staticconstintCONTINUE=100;staticconstintSWITCHING_PROTOCOLS=101;staticconstintPROCESSING=102;staticconstintEARLY_HINTS=103;// 成功状态码 (2xx)staticconstintOK=200;staticconstintCREATED=201;staticconstintACCEPTED=202;staticconstintNON_AUTHORITATIVE_INFORMATION=203;staticconstintNO_CONTENT=204;staticconstintRESET_CONTENT=205;staticconstintPARTIAL_CONTENT=206;staticconstintMULTI_STATUS=207;staticconstintALREADY_REPORTED=208;staticconstintIM_USED=226;// 重定向状态码 (3xx)staticconstintMULTIPLE_CHOICES=300;staticconstintMOVED_PERMANENTLY=301;staticconstintFOUND=302;staticconstintSEE_OTHER=303;staticconstintNOT_MODIFIED=304;staticconstintUSE_PROXY=305;staticconstintTEMPORARY_REDIRECT=307;staticconstintPERMANENT_REDIRECT=308;// 客户端错误状态码 (4xx)staticconstintBAD_REQUEST=400;staticconstintUNAUTHORIZED=401;staticconstintPAYMENT_REQUIRED=402;staticconstintFORBIDDEN=403;staticconstintNOT_FOUND=404;staticconstintMETHOD_NOT_ALLOWED=405;staticconstintNOT_ACCEPTABLE=406;staticconstintPROXY_AUTHENTICATION_REQUIRED=407;staticconstintREQUEST_TIMEOUT=408;staticconstintCONFLICT=409;staticconstintGONE=410;staticconstintLENGTH_REQUIRED=411;staticconstintPRECONDITION_FAILED=412;staticconstintPAYLOAD_TOO_LARGE=413;staticconstintURI_TOO_LONG=414;staticconstintUNSUPPORTED_MEDIA_TYPE=415;staticconstintRANGE_NOT_SATISFIABLE=416;staticconstintEXPECTATION_FAILED=417;staticconstintIM_A_TEAPOT=418;// RFC 2324staticconstintMISDIRECTED_REQUEST=421;staticconstintUNPROCESSABLE_ENTITY=422;staticconstintLOCKED=423;staticconstintFAILED_DEPENDENCY=424;staticconstintTOO_EARLY=425;staticconstintUPGRADE_REQUIRED=426;staticconstintPRECONDITION_REQUIRED=428;staticconstintTOO_MANY_REQUESTS=429;staticconstintREQUEST_HEADER_FIELDS_TOO_LARGE=431;staticconstintUNAVAILABLE_FOR_LEGAL_REASONS=451;// 服务器错误状态码 (5xx)staticconstintINTERNAL_SERVER_ERROR=500;staticconstintNOT_IMPLEMENTED=501;staticconstintBAD_GATEWAY=502;staticconstintSERVICE_UNAVAILABLE=503;staticconstintGATEWAY_TIMEOUT=504;staticconstintHTTP_VERSION_NOT_SUPPORTED=505;staticconstintVARIANT_ALSO_NEGOTIATES=506;staticconstintINSUFFICIENT_STORAGE=507;staticconstintLOOP_DETECTED=508;staticconstintNOT_EXTENDED=510;staticconstintNETWORK_AUTHENTICATION_REQUIRED=511;// 获取状态码描述staticstd::stringget_status_message(intcode){switch(code){// 1xxcase100:return"Continue";case101:return"Switching Protocols";case102:return"Processing";case103:return"Early Hints";// 2xxcase200:return"OK";case201:return"Created";case202:return"Accepted";case203:return"Non-Authoritative Information";case204:return"No Content";case205:return"Reset Content";case206:return"Partial Content";case207:return"Multi-Status";case208:return"Already Reported";case226:return"IM Used";// 3xxcase300:return"Multiple Choices";case301:return"Moved Permanently";case302:return"Found";case303:return"See Other";case304:return"Not Modified";case305:return"Use Proxy";case307:return"Temporary Redirect";case308:return"Permanent Redirect";// 4xxcase400:return"Bad Request";case401:return"Unauthorized";case402:return"Payment Required";case403:return"Forbidden";case404:return"Not Found";case405:return"Method Not Allowed";case406:return"Not Acceptable";case407:return"Proxy Authentication Required";case408:return"Request Timeout";case409:return"Conflict";case410:return"Gone";case411:return"Length Required";case412:return"Precondition Failed";case413:return"Payload Too Large";case414:return"URI Too Long";case415:return"Unsupported Media Type";case416:return"Range Not Satisfiable";case417:return"Expectation Failed";case418:return"I'm a teapot";case421:return"Misdirected Request";case422:return"Unprocessable Entity";case423:return"Locked";case424:return"Failed Dependency";case425:return"Too Early";case426:return"Upgrade Required";case428:return"Precondition Required";case429:return"Too Many Requests";case431:return"Request Header Fields Too Large";case451:return"Unavailable For Legal Reasons";// 5xxcase500:return"Internal Server Error";case501:return"Not Implemented";case502:return"Bad Gateway";case503:return"Service Unavailable";case504:return"Gateway Timeout";case505:return"HTTP Version Not Supported";case506:return"Variant Also Negotiates";case507:return"Insufficient Storage";case508:return"Loop Detected";case510:return"Not Extended";case511:return"Network Authentication Required";default:return"Unknown Status Code";}}// 判断状态码类别staticstd::stringget_status_category(intcode){if(code>=100&&code<200)return"Informational";if(code>=200&&code<300)return"Successful";if(code>=300&&code<400)return"Redirection";if(code>=400&&code<500)return"Client Error";if(code>=500&&code<600)return"Server Error";return"Unknown";}};

2.4.2 HTTP头部字段详解

HTTP头部字段包含丰富的信息，用于控制请求和响应的行为：

classHttpHeaders{public:// 通用头部字段staticconstchar*CACHE_CONTROL;staticconstchar*CONNECTION;staticconstchar*DATE;staticconstchar*PRAGMA;staticconstchar*TRAILER;staticconstchar*TRANSFER_ENCODING;staticconstchar*UPGRADE;staticconstchar*VIA;staticconstchar*WARNING;// 请求头部字段staticconstchar*ACCEPT;staticconstchar*ACCEPT_CHARSET;staticconstchar*ACCEPT_ENCODING;staticconstchar*ACCEPT_LANGUAGE;staticconstchar*AUTHORIZATION;staticconstchar*EXPECT;staticconstchar*FROM;staticconstchar*HOST;staticconstchar*IF_MATCH;staticconstchar*IF_MODIFIED_SINCE;staticconstchar*IF_NONE_MATCH;staticconstchar*IF_RANGE;staticconstchar*IF_UNMODIFIED_SINCE;staticconstchar*MAX_FORWARDS;staticconstchar*PROXY_AUTHORIZATION;staticconstchar*RANGE;staticconstchar*REFERER;staticconstchar*TE;staticconstchar*USER_AGENT;// 响应头部字段staticconstchar*ACCEPT_RANGES;staticconstchar*AGE;staticconstchar*ETAG;staticconstchar*LOCATION;staticconstchar*PROXY_AUTHENTICATE;staticconstchar*RETRY_AFTER;staticconstchar*SERVER;staticconstchar*VARY;staticconstchar*WWW_AUTHENTICATE;// 实体头部字段staticconstchar*ALLOW;staticconstchar*CONTENT_ENCODING;staticconstchar*CONTENT_LANGUAGE;staticconstchar*CONTENT_LENGTH;staticconstchar*CONTENT_LOCATION;staticconstchar*CONTENT_MD5;staticconstchar*CONTENT_RANGE;staticconstchar*CONTENT_TYPE;staticconstchar*EXPIRES;staticconstchar*LAST_MODIFIED;// Cookie相关staticconstchar*COOKIE;staticconstchar*SET_COOKIE;// 安全相关staticconstchar*STRICT_TRANSPORT_SECURITY;staticconstchar*X_CONTENT_TYPE_OPTIONS;staticconstchar*X_XSS_PROTECTION;staticconstchar*X_FRAME_OPTIONS;staticconstchar*CONTENT_SECURITY_POLICY;// CORS相关staticconstchar*ACCESS_CONTROL_ALLOW_ORIGIN;staticconstchar*ACCESS_CONTROL_ALLOW_METHODS;staticconstchar*ACCESS_CONTROL_ALLOW_HEADERS;staticconstchar*ACCESS_CONTROL_ALLOW_CREDENTIALS;staticconstchar*ACCESS_CONTROL_EXPOSE_HEADERS;staticconstchar*ACCESS_CONTROL_MAX_AGE;staticconstchar*ACCESS_CONTROL_REQUEST_METHOD;staticconstchar*ACCESS_CONTROL_REQUEST_HEADERS;staticconstchar*ORIGIN;};// 初始化静态成员constchar*HttpHeaders::CACHE_CONTROL="Cache-Control";constchar*HttpHeaders::CONNECTION="Connection";constchar*HttpHeaders::DATE="Date";constchar*HttpHeaders::PRAGMA="Pragma";constchar*HttpHeaders::TRAILER="Trailer";constchar*HttpHeaders::TRANSFER_ENCODING="Transfer-Encoding";constchar*HttpHeaders::UPGRADE="Upgrade";constchar*HttpHeaders::VIA="Via";constchar*HttpHeaders::WARNING="Warning";constchar*HttpHeaders::ACCEPT="Accept";constchar*HttpHeaders::ACCEPT_CHARSET="Accept-Charset";constchar*HttpHeaders::ACCEPT_ENCODING="Accept-Encoding";constchar*HttpHeaders::ACCEPT_LANGUAGE="Accept-Language";constchar*HttpHeaders::AUTHORIZATION="Authorization";constchar*HttpHeaders::EXPECT="Expect";constchar*HttpHeaders::FROM="From";constchar*HttpHeaders::HOST="Host";constchar*HttpHeaders::IF_MATCH="If-Match";constchar*HttpHeaders::IF_MODIFIED_SINCE="If-Modified-Since";constchar*HttpHeaders::IF_NONE_MATCH="If-None-Match";constchar*HttpHeaders::IF_RANGE="If-Range";constchar*HttpHeaders::IF_UNMODIFIED_SINCE="If-Unmodified-Since";constchar*HttpHeaders::MAX_FORWARDS="Max-Forwards";constchar*HttpHeaders::PROXY_AUTHORIZATION="Proxy-Authorization";constchar*HttpHeaders::RANGE="Range";constchar*HttpHeaders::REFERER="Referer";constchar*HttpHeaders::TE="Te";constchar*HttpHeaders::USER_AGENT="User-Agent";constchar*HttpHeaders::ACCEPT_RANGES="Accept-Ranges";constchar*HttpHeaders::AGE="Age";constchar*HttpHeaders::ETAG="ETag";constchar*HttpHeaders::LOCATION="Location";constchar*HttpHeaders::PROXY_AUTHENTICATE="Proxy-Authenticate";constchar*HttpHeaders::RETRY_AFTER="Retry-After";constchar*HttpHeaders::SERVER="Server";constchar*HttpHeaders::VARY="Vary";constchar*HttpHeaders::WWW_AUTHENTICATE="WWW-Authenticate";constchar*HttpHeaders::ALLOW="Allow";constchar*HttpHeaders::CONTENT_ENCODING="Content-Encoding";constchar*HttpHeaders::CONTENT_LANGUAGE="Content-Language";constchar*HttpHeaders::CONTENT_LENGTH="Content-Length";constchar*HttpHeaders::CONTENT_LOCATION="Content-Location";constchar*HttpHeaders::CONTENT_MD5="Content-MD5";constchar*HttpHeaders::CONTENT_RANGE="Content-Range";constchar*HttpHeaders::CONTENT_TYPE="Content-Type";constchar*HttpHeaders::EXPIRES="Expires";constchar*HttpHeaders::LAST_MODIFIED="Last-Modified";constchar*HttpHeaders::COOKIE="Cookie";constchar*HttpHeaders::SET_COOKIE="Set-Cookie";constchar*HttpHeaders::STRICT_TRANSPORT_SECURITY="Strict-Transport-Security";constchar*HttpHeaders::X_CONTENT_TYPE_OPTIONS="X-Content-Type-Options";constchar*HttpHeaders::X_XSS_PROTECTION="X-XSS-Protection";constchar*HttpHeaders::X_FRAME_OPTIONS="X-Frame-Options";constchar*HttpHeaders::CONTENT_SECURITY_POLICY="Content-Security-Policy";constchar*HttpHeaders::ACCESS_CONTROL_ALLOW_ORIGIN="Access-Control-Allow-Origin";constchar*HttpHeaders::ACCESS_CONTROL_ALLOW_METHODS="Access-Control-Allow-Methods";constchar*HttpHeaders::ACCESS_CONTROL_ALLOW_HEADERS="Access-Control-Allow-Headers";constchar*HttpHeaders::ACCESS_CONTROL_ALLOW_CREDENTIALS="Access-Control-Allow-Credentials";constchar*HttpHeaders::ACCESS_CONTROL_EXPOSE_HEADERS="Access-Control-Expose-Headers";constchar*HttpHeaders::ACCESS_CONTROL_MAX_AGE="Access-Control-Max-Age";constchar*HttpHeaders::ACCESS_CONTROL_REQUEST_METHOD="Access-Control-Request-Method";constchar*HttpHeaders::ACCESS_CONTROL_REQUEST_HEADERS="Access-Control-Request-Headers";constchar*HttpHeaders::ORIGIN="Origin";// Content-Type常用值classContentTypes{public:staticconstchar*TEXT_HTML;staticconstchar*TEXT_PLAIN;staticconstchar*TEXT_CSS;staticconstchar*TEXT_JAVASCRIPT;staticconstchar*APPLICATION_JSON;staticconstchar*APPLICATION_XML;staticconstchar*APPLICATION_X_WWW_FORM_URLENCODED;staticconstchar*MULTIPART_FORM_DATA;staticconstchar*IMAGE_JPEG;staticconstchar*IMAGE_PNG;staticconstchar*IMAGE_GIF;staticconstchar*APPLICATION_OCTET_STREAM;};constchar*ContentTypes::TEXT_HTML="text/html; charset=utf-8";constchar*ContentTypes::TEXT_PLAIN="text/plain; charset=utf-8";constchar*ContentTypes::TEXT_CSS="text/css; charset=utf-8";constchar*ContentTypes::TEXT_JAVASCRIPT="text/javascript; charset=utf-8";constchar*ContentTypes::APPLICATION_JSON="application/json; charset=utf-8";constchar*ContentTypes::APPLICATION_XML="application/xml; charset=utf-8";constchar*ContentTypes::APPLICATION_X_WWW_FORM_URLENCODED="application/x-www-form-urlencoded";constchar*ContentTypes::MULTIPART_FORM_DATA="multipart/form-data";constchar*ContentTypes::IMAGE_JPEG="image/jpeg";constchar*ContentTypes::IMAGE_PNG="image/png";constchar*ContentTypes::IMAGE_GIF="image/gif";constchar*ContentTypes::APPLICATION_OCTET_STREAM="application/octet-stream";

2.4.3 HTTP方法详解

HTTP定义了多种请求方法，每种方法有不同的语义：

classHttpMethods{public:staticconstchar*GET;staticconstchar*POST;staticconstchar*PUT;staticconstchar*DELETE;staticconstchar*HEAD;staticconstchar*OPTIONS;staticconstchar*PATCH;staticconstchar*TRACE;staticconstchar*CONNECT;// 判断方法是否安全（不修改资源）staticboolis_safe(conststd::string&method){returnmethod==GET||method==HEAD||method==OPTIONS||method==TRACE;}// 判断方法是否幂等（多次执行结果相同）staticboolis_idempotent(conststd::string&method){returnmethod==GET||method==HEAD||method==PUT||method==DELETE||method==OPTIONS||method==TRACE;}// 判断方法是否可缓存staticboolis_cacheable(conststd::string&method){returnmethod==GET||method==HEAD;}// 获取方法描述staticstd::stringget_method_description(conststd::string&method){if(method==GET)return"获取资源";if(method==POST)return"提交数据";if(method==PUT)return"更新资源";if(method==DELETE)return"删除资源";if(method==HEAD)return"获取响应头";if(method==OPTIONS)return"获取支持的方法";if(method==PATCH)return"部分更新资源";if(method==TRACE)return"回显请求";if(method==CONNECT)return"建立隧道";return"未知方法";}};constchar*HttpMethods::GET="GET";constchar*HttpMethods::POST="POST";constchar*HttpMethods::PUT="PUT";constchar*HttpMethods::DELETE="DELETE";constchar*HttpMethods::HEAD="HEAD";constchar*HttpMethods::OPTIONS="OPTIONS";constchar*HttpMethods::PATCH="PATCH";constchar*HttpMethods::TRACE="TRACE";constchar*HttpMethods::CONNECT="CONNECT";

2.4.4 HTTP版本演进

HTTP协议有多个版本，每个版本都有重要改进：

classHttpVersions{public:staticconstchar*HTTP_0_9;staticconstchar*HTTP_1_0;staticconstchar*HTTP_1_1;staticconstchar*HTTP_2_0;staticconstchar*HTTP_3_0;// 获取版本特性staticstd::stringget_features(conststd::string&version){if(version==HTTP_0_9)return"简单文本传输，无头部，仅GET方法";if(version==HTTP_1_0)return"增加头部、状态码、多种方法，非持久连接";if(version==HTTP_1_1)return"持久连接、管道化、分块传输、缓存控制";if(version==HTTP_2_0)return"二进制分帧、多路复用、头部压缩、服务器推送";if(version==HTTP_3_0)return"基于QUIC，解决队头阻塞，0-RTT连接";return"未知版本";}// 比较版本staticboolis_greater_or_equal(conststd::string&v1,conststd::string&v2){std::vector<std::string>versions={HTTP_0_9,HTTP_1_0,HTTP_1_1,HTTP_2_0,HTTP_3_0};autoit1=std::find(versions.begin(),versions.end(),v1);autoit2=std::find(versions.begin(),versions.end(),v2);if(it1==versions.end()||it2==versions.end()){returnfalse;}returnstd::distance(versions.begin(),it1)>=std::distance(versions.begin(),it2);}};constchar*HttpVersions::HTTP_0_9="HTTP/0.9";constchar*HttpVersions::HTTP_1_0="HTTP/1.0";constchar*HttpVersions::HTTP_1_1="HTTP/1.1";constchar*HttpVersions::HTTP_2_0="HTTP/2.0";constchar*HttpVersions::HTTP_3_0="HTTP/3.0";

三、代码验证与实践

3.1 发送简单HTTP响应

在前面的代码基础上，我们现在实现一个完整的HTTP服务器，能够处理各种HTTP请求并返回响应。

// 完整的HTTP服务器实现#include"HttpRequest.h"#include"HttpResponse.h"#include"Reactor.h"#include<iostream>#include<fstream>#include<filesystem>#include<json/json.h>namespacefs=std::filesystem;classHttpServerHandler:publicEventHandler{private:intserver_fd;Reactor*reactor;std::string root_dir;// 网站根目录public:HttpServerHandler(intfd,Reactor*r,conststd::string&root):server_fd(fd),reactor(r),root_dir(root){}intget_handle()constoverride{returnserver_fd;}voidhandle_event(intfd,uint32_tevents)override{if(events&EPOLLIN){handle_accept();}}private:voidhandle_accept(){structsockaddr_inclient_addr;socklen_t addr_len=sizeof(client_addr);while(true){intclient_fd=accept(server_fd,(structsockaddr*)&client_addr,&addr_len);if(client_fd<0){if(errno==EAGAIN||errno==EWOULDBLOCK){break;}else{perror("accept failed");break;}}// 创建客户端连接处理器ClientHandler*handler=newClientHandler(client_fd,reactor,client_addr,root_dir);reactor->register_handler(handler,EPOLLIN|EPOLLET);}}};classClientHandler:publicEventHandler{private:intclient_fd;Reactor*reactor;structsockaddr_inclient_addr;std::string root_dir;HttpRequest request;HttpResponse response;std::string in_buffer;std::string out_buffer;enumState{READING_REQUEST,PROCESSING,SENDING_RESPONSE,CLOSING};State state;public:ClientHandler(intfd,Reactor*r,conststructsockaddr_in&addr,conststd::string&root):client_fd(fd),reactor(r),client_addr(addr),root_dir(root),state(READING_REQUEST){// 设置非阻塞intflags=fcntl(fd,F_GETFL,0);fcntl(fd,F_SETFL,flags|O_NONBLOCK);}~ClientHandler(){if(client_fd>=0){close(client_fd);}}intget_handle()constoverride{returnclient_fd;}voidhandle_event(intfd,uint32_tevents)override{try{if(events&EPOLLIN){handle_read();}if(events&EPOLLOUT){handle_write();}if(events&(EPOLLERR|EPOLLHUP)){cleanup();}}catch(conststd::exception&e){std::cerr<<"Error handling client: "<<e.what()<<std::endl;cleanup();}}private:voidhandle_read(){charbuffer[8192];ssize_t n=read(client_fd,buffer,sizeof(buffer));if(n>0){in_buffer.append(buffer,n);// 尝试解析请求if(state==READING_REQUEST){if(try_parse_request()){state=PROCESSING;process_request();state=SENDING_RESPONSE;prepare_response();}}}elseif(n==0){// 客户端关闭连接cleanup();}else{if(errno!=EAGAIN&&errno!=EWOULDBLOCK){perror("read error");cleanup();}}}booltry_parse_request(){// 检查是否收到完整的请求size_t header_end=in_buffer.find("\r\n\r\n");if(header_end==std::string::npos){returnfalse;// 头部不完整}// 解析头部std::string headers_part=in_buffer.substr(0,header_end+4);if(!request.parse(headers_part)){send_error_response(400,"Bad Request");returnfalse;}// 检查是否需要正文size_t content_length=request.get_content_length();if(content_length>0){size_t body_start=header_end+4;size_t body_received=in_buffer.length()-body_start;if(body_received<content_length){returnfalse;// 正文不完整}// 提取正文std::string body=in_buffer.substr(body_start,content_length);in_buffer.erase(0,body_start+content_length);// 重新解析包含正文的完整请求if(!request.parse(headers_part+body)){send_error_response(400,"Bad Request");returnfalse;}}else{// 没有正文，直接解析in_buffer.erase(0,header_end+4);}returntrue;}voidprocess_request(){std::string method=request.get_method();std::string uri=request.get_uri();// 安全检查：防止目录遍历攻击if(uri.find("..")!=std::string::npos){send_error_response(403,"Forbidden");return;}// 路由处理if(uri=="/"){serve_file("index.html");}elseif(uri=="/api/status"){handle_api_status();}elseif(uri=="/api/data"&&method=="GET"){handle_api_get_data();}elseif(uri=="/api/data"&&method=="POST"){handle_api_post_data();}elseif(uri=="/api/upload"&&method=="POST"){handle_api_upload();}elseif(uri.find("/api/")==0){send_error_response(404,"API endpoint not found");}else{// 静态文件服务serve_file(uri.substr(1));// 去掉开头的'/'}}voidserve_file(conststd::string&path){fs::path file_path=fs::path(root_dir)/path;// 安全检查if(!fs::exists(file_path)){send_error_response(404,"File not found: "+path);return;}if(fs::is_directory(file_path)){file_path/="index.html";if(!fs::exists(file_path)){list_directory(path);return;}}// 读取文件std::ifstreamfile(file_path,std::ios::binary);if(!file){send_error_response(500,"Cannot read file: "+path);return;}std::stringcontent((std::istreambuf_iterator<char>(file)),std::istreambuf_iterator<char>());// 根据扩展名设置Content-Typestd::string content_type=get_content_type(file_path.extension().string());response.set_status(200);response.set_body(content,content_type);// 设置缓存头response.set_header("Cache-Control","public, max-age=3600");// 设置Last-Modified头autoftime=fs::last_write_time(file_path);autosctp=std::chrono::time_point_cast<std::chrono::system_clock::duration>(ftime-fs::file_time_type::clock::now()+std::chrono::system_clock::now());std::time_t cftime=std::chrono::system_clock::to_time_t(sctp);chartime_buf[100];std::strftime(time_buf,sizeof(time_buf),"%a, %d %b %Y %H:%M:%S GMT",std::gmtime(&cftime));response.set_header("Last-Modified",time_buf);}voidlist_directory(conststd::string&path){fs::path dir_path=fs::path(root_dir)/path;if(!fs::exists(dir_path)||!fs::is_directory(dir_path)){send_error_response(404,"Directory not found");return;}std::stringstream html;html<<"<html><head><title>Directory listing for /"<<path<<"</title></head>";html<<"<body><h1>Directory listing for /"<<path<<"</h1><hr><ul>";// 上级目录链接if(path!=""){html<<"<li><a href=\"../\">../</a></li>";}// 目录内容for(constauto&entry:fs::directory_iterator(dir_path)){std::string filename=entry.path().filename().string();boolis_dir=fs::is_directory(entry.path());html<<"<li><a href=\""<<filename;if(is_dir)html<<"/";html<<"\">"<<filename;if(is_dir)html<<"/";html<<"</a></li>";}html<<"</ul><hr></body></html>";response.set_status(200);response.set_body(html.str());}voidhandle_api_status(){Json::Value json;json["status"]="ok";json["timestamp"]=static_cast<Json::UInt64>(time(nullptr));json["server"]="SimpleHTTPServer/1.0";json["clients"]=1;// 简化处理，实际应该是当前连接数Json::StreamWriterBuilder writer;std::string json_str=Json::writeString(writer,json);response=HttpResponse::make_json_response(json_str);}voidhandle_api_get_data(){autoparams=request.get_query_params();Json::Value json;json["method"]="GET";json["timestamp"]=static_cast<Json::UInt64>(time(nullptr));if(!params.empty()){Json::Value params_json;for(constauto&param:params){params_json[param.first]=param.second;}json["parameters"]=params_json;}Json::StreamWriterBuilder writer;std::string json_str=Json::writeString(writer,json);response=HttpResponse::make_json_response(json_str);}voidhandle_api_post_data(){autoform_data=request.get_form_data();Json::Value json;json["method"]="POST";json["timestamp"]=static_cast<Json::UInt64>(time(nullptr));if(!form_data.empty()){Json::Value data_json;for(constauto&data:form_data){data_json[data.first]=data.second;}json["form_data"]=data_json;}Json::StreamWriterBuilder writer;std::string json_str=Json::writeString(writer,json);response=HttpResponse::make_json_response(json_str);}voidhandle_api_upload(){// 简单的上传处理response.set_status(200);response.set_body("<html><body><h1>Upload Received</h1><p>File uploaded successfully</p></body></html>");}voidsend_error_response(intcode,conststd::string&message){response=HttpResponse::make_error_response(code,message);}voidprepare_response(){out_buffer=response.build();// 更新事件监听，准备写入structepoll_eventev;ev.events=EPOLLOUT|EPOLLET;ev.data.ptr=this;epoll_ctl(reactor->get_handle(),EPOLL_CTL_MOD,client_fd,&ev);}voidhandle_write(){if(!out_buffer.empty()){ssize_t n=write(client_fd,out_buffer.data(),out_buffer.size());if(n>0){out_buffer.erase(0,n);}else{if(errno!=EAGAIN&&errno!=EWOULDBLOCK){perror("write error");cleanup();return;}}}if(out_buffer.empty()){// 检查是否为keep-alive连接if(request.is_keep_alive()){// 重置状态，准备处理下一个请求in_buffer.clear();request=HttpRequest();response=HttpResponse();state=READING_REQUEST;// 重新监听读事件structepoll_eventev;ev.events=EPOLLIN|EPOLLET;ev.data.ptr=this;epoll_ctl(reactor->get_handle(),EPOLL_CTL_MOD,client_fd,&ev);}else{cleanup();}}}voidcleanup(){reactor->remove_handler(this);deletethis;}std::stringget_content_type(conststd::string&extension){staticstd::map<std::string,std::string>mime_types={{".html",ContentTypes::TEXT_HTML},{".htm",ContentTypes::TEXT_HTML},{".css",ContentTypes::TEXT_CSS},{".js",ContentTypes::TEXT_JAVASCRIPT},{".json",ContentTypes::APPLICATION_JSON},{".xml",ContentTypes::APPLICATION_XML},{".txt",ContentTypes::TEXT_PLAIN},{".jpg",ContentTypes::IMAGE_JPEG},{".jpeg",ContentTypes::IMAGE_JPEG},{".png",ContentTypes::IMAGE_PNG},{".gif",ContentTypes::IMAGE_GIF},{".ico","image/x-icon"},{".svg","image/svg+xml"},{".pdf","application/pdf"},{".zip","application/zip"},{".gz","application/gzip"},};autoit=mime_types.find(extension);if(it!=mime_types.end()){returnit->second;}returnContentTypes::APPLICATION_OCTET_STREAM;}};// 主函数intmain(intargc,char*argv[]){intport=8080;std::string root_dir=".";// 解析命令行参数for(inti=1;i<argc;i++){std::string arg=argv[i];if(arg=="-p"&&i+1<argc){port=std::stoi(argv[++i]);}elseif(arg=="-d"&&i+1<argc){root_dir=argv[++i];}elseif(arg=="-h"){std::cout<<"Usage: "<<argv[0]<<" [-p port] [-d directory]"<<std::endl;return0;}}// 检查根目录if(!fs::exists(root_dir)||!fs::is_directory(root_dir)){std::cerr<<"Error: Directory '"<<root_dir<<"' does not exist or is not a directory"<<std::endl;return1;}// 创建socketintserver_fd=socket(AF_INET,SOCK_STREAM,0);if(server_fd<0){perror("socket creation failed");return1;}// 设置socket选项intopt=1;if(setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt))<0){perror("setsockopt failed");close(server_fd);return1;}// 绑定地址structsockaddr_inserver_addr;memset(&server_addr,0,sizeof(server_addr));server_addr.sin_family=AF_INET;server_addr.sin_addr.s_addr=htonl(INADDR_ANY);server_addr.sin_port=htons(port);if(bind(server_fd,(structsockaddr*)&server_addr,sizeof(server_addr))<0){perror("bind failed");close(server_fd);return1;}// 监听连接if(listen(server_fd,SOMAXCONN)<0){perror("listen failed");close(server_fd);return1;}// 设置非阻塞intflags=fcntl(server_fd,F_GETFL,0);fcntl(server_fd,F_SETFL,flags|O_NONBLOCK);// 创建并启动ReactorReactor reactor;if(!reactor.init()){std::cerr<<"Failed to initialize reactor"<<std::endl;close(server_fd);return1;}// 创建服务器处理器HttpServerHandler*server_handler=newHttpServerHandler(server_fd,&reactor,root_dir);reactor.register_handler(server_handler,EPOLLIN|EPOLLET);std::cout<<"HTTP Server started on port "<<port<<std::endl;std::cout<<"Serving directory: "<<fs::absolute(root_dir)<<std::endl;std::cout<<"Press Ctrl+C to stop"<<std::endl;// 启动事件循环reactor.event_loop();deleteserver_handler;close(server_fd);return0;}