【Mudo】实战项目之应用层模块

于 2024-08-18 22:57:31 发布
阅读量513 收藏 11
点赞数 8
分类专栏： mudo库 文章标签： mudo http 高并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shun_Hua/article/details/141298212
版权

文章目录

前言

在上一篇文章当中，博主从代码的层面介绍了服务器模块的实现，最终封装出了一个传输层的TcpServer模块，那么在本篇将进一步向上拓展出一个应用层——Http服务器，用以进行Http连接的业务处理。话不多说，但强调一点，需将本专栏的前两篇文章消化完毕之后，再看本篇。

正文

1. Util

说明：Util可以是个类，里面封装各种静态接口，也可以使用命名空间，目的都是为了使用作用域防止命名污染。如下介绍接口时默认是在作用域范围内部的，不再赘述，有兴趣可通过上篇文章的源码连接查看。

1.1 File

读写

  • C++IO流获取文件大小
 std::ifstream ifs(filename,std::ios::binary);//二进制的方式打开
 ifs.seekg(0,ifs.end);//到文件的末尾
 size_t fsz = ifs.tellg();//从开始到末尾的大小
 ifs.seekg(0,ifs.beg);//调整到文件开始处

    static bool ReadFile(const std::string filename,std::string* str)
    {
        //1.打开文件
        std::ifstream ifs(filename,std::ios::binary);
        if(false == ifs.is_open())
        {
            return false;
        }
        //2.获取文件大小
        ifs.seekg(0,ifs.end);
        size_t fsz = ifs.tellg();
        str->resize(fsz);//将str扩容至文件的大小
        ifs.seekg(0,ifs.beg);
        //3.读取文件内容
        ifs.read(&(*str)[0],fsz);
        if(false == ifs.good())
        {
            return false;
        }
        return true;
    }
    static bool WriteFile(const std::string filename,const std::string& str)
    {
        std::ofstream ofs(filename,std::ios::binary | std::ios::trunc);//以二进制且以清空的方式打开
        if(false == ofs.is_open())
        {
            return false;
        }
        else
        {
            ofs.write(&str[0],str.size());
            if(false == ofs.good())
            {
                return false;
            }
        }
        return true;
    }

类型判断

  • 接口
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
int stat(const char *pathname, struct stat *statbuf);
/*
参数：
	1.pathname，输入型参数,文件名。
	2.statbuf,输出型参数，用于存放文件的属性信息。stat.st_mode,类型为mode_t,此处用于判断文件的类型。
	类型判断的宏：S_ISDIR(mode_t)用于判断是否为目录,S_ISREG(mode_t)用于判断是否为普通文件。
返回值：
	1.成功返回0。
	2.失败返回-1,并设置合适的错误码。
*/


bool IsRegular(const std::string& filename)
{
    return S_ISREG(Kind(filename));
}
bool IsDir(const std::string& filename)
{
    return S_ISDIR(Kind(filename));
}
mode_t Kind(const std::string& filename)
{
    struct stat st;
    int ret = stat(filename.c_str(),&st);
    if(ret < 0)
    {
    	//错误
    }
    return st.st_mode;
}

1.2 Url

编码与解码

编码规则：

URL，即统一资源定位符，也就是所谓的网址，比如说https://www.google.com/search?q=C%2B%2B，其中q=C%2B%2B，就是我们要搜索的参数，我本来搜索的是C++，但是其中的++与网址的标准格式的字符冲突被编码，可能会使处理出错，因此需要编码。

Http的标准格式：
在这里插入图片描述

解释完为啥需要编码，再来谈谈如何进行编码：

  1. .， -， _ ，~， 字母，数字为绝对不编码字符，因此不用进行转换。
  2. 空格根据不同的标准可能进行转化，W3cb标准必须被编码为+，RFC2396要转换为%%HH格式。
  3. 其它的字符统一转换成%%HH格式，即百分号 + 两位十六进制。
  • 接口：
  1. 用于判断是否字母或者字符
#include<ctype.h>  
int isalpha(int c)
/*
参数：字符
返回值：如果是则为非0值，不是则为0值.
*/
  1. 用于将10进制(int)转换为16进制(string)，以字符串的形式输出。
 std::stringstream ssm;
 ssm << std::uppercase << std::setw(2) << std::setfill('0') << std::hex << dec;
 //ssm.str()获取转换的string

实现：

    static std::string UrlIncode(const std::string& iurl, bool is_w3c) 
    {

        
        //3.判断为字母和数字的接口：#include<ctype.h>  int isalpha(int c)
        std::string res;
        for(auto c : iurl)
        {
        	//[. - _ ~ 字母 数字]不属于绝对不编码字符
            if(c == '.' || c == '-' || c == '_' || c == '~' || isalpha(c))
            {
                res += c;
            }
            //空格W3c必须被编码为+
            else if(c == ' ' && is_w3c)
            {
                res += '+';
            }
            //其余要转换为%%HH格式
            else
            {
                int dec = c;
                std::stringstream ssm;
                ssm << std::uppercase << std::setw(2) << std::setfill('0') << std::hex << dec;
                res += ("%" + ssm.str());
            }
        }
        return res;
    }
    static std::string UrlDecode(const std::string& durl,bool is_w3c)
    {
        std::string res;
        for(int i = 0; i < durl.size();)
        {
            if(durl[i] == '%')
            {
                std::string hnum = durl.substr(i + 1,2);
                int c = stoi(hnum,nullptr,16);
                res += c;
                i += 3; 
            }
            else 
            {
                if(durl[i] == '+' && is_w3c)
                    res += ' ';
                else
                    res += durl[i];
                
                i += 1;
            }
        }
        return res; 
    }

资源路径是否有效

  • 思路：资源路径不能跑到资源的根目录上面，比如https://blog.csdn.net/…/就会被判定为无效，CSDN网站处理的是返回网站的首页，但是本项目的实现强硬了一些，直接非法，最终会返回错误界面。
    static bool Valid(const std::string& filename)
    {
    
        std::vector<std::string> dirs;
        //下文会提及的，这里是将字符串按照"/"切分存储到dirs中目的是将路径进行切分。
        Split(filename,"/",&dirs); 
        int level = 0;
        for(auto& d : dirs)
        {
            if(d == "..")
            {
                if(--level < 0) 
                {
                    return false;
                }
            }
            else
            {
                level++;
            } 
        }
        return true;
    }

1.3 Str

分割字符串，本项目主要是在解析请求行用到，此函数是仿照Boost库中的split函数实现的，也可以使用其提供的函数。

  • boost接口
//说明：需按照Boost库才可使用
#include<boost/algorithm/string/string.hpp>
template<typename SequenceSequenceT, typename RangeT, typename PredicateT> 
  SequenceSequenceT & split(SequenceSequenceT & Result, RangeT & Input, PredicateT Pred, 
        token_compress_mode_type eCompress = token_compress_off);
/*
参数
	1:vector<type>类型的，用于存放切割后的内容。
	2：切割的内容。
	3：分割符。
	4：切割的模式，一般设置为token_compress_on,意为将连续的分割符看成一个。
返回值 
	vector<type>类型的引用
*/
  • 接口
 size_t find(string str,int pos); //从pos位置开始找str
 std::string substr (int pos,int len);//从pos位置切割len长度的字符串
  • 实现
    static int Split(const std::string src,const std::string sep,std::vector<std::string> *arr)
    {
        
        int pos = 0;
        arr->resize(0);
        while (pos < src.size())
        {
            size_t offset = src.find(sep,pos);
            if(offset == std::string::npos)
            {
                arr->push_back(src.substr(pos));
                break;
            }
            else if(offset != pos)
            {
                arr->push_back(src.substr(pos,offset - pos));
            }
            pos = offset + sep.size();
        }
        return arr->size();
    }

1.4 Infor

响应行是这样的——HTTP/1.1 200 OK，此处的响应状态码和响应信息是对应的关系，因此可以使用哈希表的形式进行存储。

说明：响应状态码和与之对应的响应信息可在RFC文档 查看，在这里偷偷告诉你一个小技巧，即将对应信息喂给AI助手，让其帮你生成一个对应格式的数据，你可以告诉举个例子告诉AI生成{100, "Continue"},的数据然后让其输出，可以少一些Cv。

Status

 static std::string Statu(int stat)
 {
     auto it = _stu.find(stat);
     if(it != _stu.end())
     {
         return it->second;
     }
     return "Unknow";
 }
std::unordered_map<int, std::string> Util::_stu = 
{
    {100, "Continue"},
    {101, "Switching Protocols"},
    {200, "OK"},
    {201, "Created"},
    {202, "Accepted"},
    {203, "Non-Authoritative Information"},
    {204, "No Content"},
    {205, "Reset Content"},
    {206, "Partial Content"},
    {300, "Multiple Choices"},
    {301, "Moved Permanently"},
    {302, "Found"},
    {303, "See Other"},
    {304, "Not Modified"},
    {305, "Use Proxy"},
    {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"},
    {426, "Upgrade Required"},
    {451, "Unavailable For Legal Reasons"},
    {500, "Internal Server Error"},
    {501, "Not Implemented"},
    {502, "Bad Gateway"},
    {503, "Service Unavailable"},
    {504, "Gateway Timeout"},
    {505, "HTTP Version Not Supported"}
};

Mine

在Http协议格式中，需要说明响应正文是什么类型的，因此需要消息头中的Content-Type字段，而Mine类型则用于表示响应的格式，比如如果是.png类型的，则为Content-Type: image/png，而image/png即为Mine类型对于文件的描述形式。

说明：Mine类型可在RFC官方文档 进行查看，或者从网上翻一翻常见的或者让AI帮你生成一份常见的也行。

static std::string Mine(const std::string& filename)
{
    int pos = filename.find(".");
    if(pos == std::string::npos)
    {
    	//二进制数据，通常用于不知道文件类型时使用。
        return "application/octet-stream";
    }
    auto it = _mine.find(filename.substr(pos));
    if(it == _mine.end())
    {
        return "application/octet-stream";
    }
    return it->second;
}
std::unordered_map<std::string, std::string> Util::_mine = 
{
    {".txt", "text/plain"},
    {".pdf", "application/pdf"},
    {".doc", "application/msword"},
    {".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
    {".xls", "application/vnd.ms-excel"},
    {".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
    {".ppt", "application/vnd.ms-powerpoint"},
    {".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
    {".jpg", "image/jpeg"},
    {".jpeg", "image/jpeg"},
    {".png", "image/png"},
    {".gif", "image/gif"},
    {".bmp", "image/bmp"},
    {".svg", "image/svg+xml"},
    {".html", "text/html"},
    {".css", "text/css"},
    {".js", "application/javascript"},
    {".xml", "application/xml"},
    {".json", "application/json"},
    {".zip", "application/zip"},
    {".rar", "application/x-rar-compressed"},
    {".tar", "application/x-tar"},
    {".gz", "application/gzip"},
    {".mp3", "audio/mpeg"},
    {".wav", "audio/wav"},
    {".mp4", "video/mp4"},
    {".avi", "video/x-msvideo"},
    {".mkv", "video/x-matroska"},
    {".exe", "application/octet-stream"},
    {".dll", "application/octet-stream"},
    {".bat", "application/x-bat"},
    {".sh", "application/x-shellscript"},
    {".py", "text/x-python"},
    {".java", "text/x-java-source"},
    {".c", "text/x-c"},
    {".cpp", "text/x-c++"},
    {".h", "text/x-c-header"},
    {".sql", "application/x-sql"},
    {".csv", "text/csv"},
    {".log", "text/plain"},
    {".md", "text/markdown"},
    {".psd", "image/vnd.adobe.photoshop"},
    {".indd", "application/vnd.adobe.indesign"}
};

2. Http

2.1 Request

请求协议格式：
在这里插入图片描述
此类所做的只是将协议打散为类的成员元素，方便进行管理，做一些增删改查的功能。

struct HttpRequest
{
    //查找,修改,获取头部字段。
    bool HasHeader(const std::string& hdr)
    {
        auto it = _headers.find(hdr);
        if(it != _headers.end()) return true;
        return false;
    }
    void SetHeader(const std::string& key,const std::string& val)
    {
        auto it = _headers.find(key);
        if(it != _headers.end()) return;
        _headers.insert({key,val});
    }
    std::string GetHeader(const std::string& hdr)
    {
        auto it = _headers.find(hdr);
        if(it != _headers.end()) return it->second;
        return "Unknow Header";
    }
    //查找,修改,获取消息头，或者说请求报头也可以字段。
    bool HasParm(const std::string& par)
    {
        auto it = _parameter.find(par);
        if(it != _parameter.end()) return true;
        return false;
    }
    void SetParm(const std::string& key,const std::string& val)
    {
        auto it = _parameter.find(key);
        if(it != _parameter.end()) return;
        _parameter.insert({key,val});        
    }
    std::string GetParm(const std::string& par)
    {
        auto it = _parameter.find(par);
        if(it != _parameter.end()) return it->second;
        return "Unknow Parameter";
    }
    //判断是否为短连接
    bool Close()
    {
        const std::string& hdr = "Connection";
        if(true == HasHeader(hdr) && GetHeader(hdr) == "keep-alive")
        {
            return false;
        }
        return true;
    }
    //获取正文长度
    size_t GetBodyLen()
    {
        std::string slen = GetHeader("Content-Length");
        if(slen == "Unknow Header")
        {
            return 0;
        }
        return stoi(slen);
    }
    //重置清除信息
    void Reset()
    {
        std::smatch tmp;
        _sch.swap(tmp);
        _method.clear();
        _version.clear();
        _source_dir.clear();
        _parameter.clear();
        _headers.clear();
        _body.clear();
    }
    std::smatch _sch; //解析头部字段，动态请求资源路径处理的参数
    std::string _method;//请求方法
    std::string _version; //版本
    std::string _source_dir; //资源路径
    std::unordered_map<std::string,std::string> _parameter;//查询参数
    std::unordered_map<std::string,std::string> _headers;//消息头
    std::string _body;//消息体
};

2.2 Response

响应协议格式：
在这里插入图片描述
此类所做的与Request相同，是对连接响应信息的管理，特殊地消息头为Location: 即服务器的url可能会重定向，因此需要进行特殊判断。

struct HttpResponse
{
    HttpResponse(int stat = 200):_stau(stat),_is_redir(false){};
    //查找,修改,获取头部字段。
    bool HasHeader(const std::string& hdr)
    {
        auto it = _headers.find(hdr);
        if(it != _headers.end()) return true;
        return false;
    }
    void SetHeader(const std::string& key,const std::string& val)
    {
        auto it = _headers.find(key);
        if(it != _headers.end()) return;
        _headers.insert({key,val});
    }
    std::string GetHeader(const std::string& hdr)
    {
        auto it = _headers.find(hdr);
        if(it != _headers.end()) return it->second;
        return "Unknow Header";
    }    
    //判断是否为短连接
    bool Close()
    {
        const std::string& hdr = "Connection";
        if(true == HasHeader(hdr) && GetHeader(hdr) == "keep-alive")
        {
            return false;
        }
        return true;
    }
    //设置重定向的URL
    void SetReRirUrl(const std::string& url,int stat)
    {
        _stau = stat;
        _is_redir = true;
        _redir_url = url;
    }    
    //设置Body正文
    void SetContent(const std::string& content,const std::string& type = "text/html")
    {
        _body = content;
        SetHeader("Content-Type",type);
    }
    int _stau;
    std::unordered_map<std::string,std::string> _headers;//消息头
    bool _is_redir;
    std::string _redir_url;
    std::string _body;
};

2.3 Context

在上下文模块中进行请求行分析主要是通过正则表达式进行处理获取请求方法，资源路径，参数，HTTP版本。
demo：

#include <iostream>
#include <sstream>
#include <string>
#include <regex>
#include <iterator>
using namespace std;
int main() 
{
	//全文匹配，使用子表达式存放解析结果，只提取出请求方法，域名信息，查询字段(可能有或者没有)。
	smatch res;
	string str = "GET /blog.csdn.net/Shun_Hua?user=xiaoming&pass=123123 HTTP/1.1\r\n";
	string pattern("(GET|HEAD|POST|PUT|DELETE) ([^?]*)(?:\\?(.*))? (HTTP/1\\.[01])(?:\r\n|\n)?");
	//(GET|HEAD|POST|PUT|DELETE)请求方法的匹配。
	//([^?]*)表示匹配非问号字符串，用于获取域名。
	//\\?，首先？是特殊字符，要想正常匹配得使用\进行转义，\也是特殊转义字符，要想使用得再使用\进行转义。
	//(.*)，.*是对任意字符串进行匹配。
	//?:\\?，表示不提取?到res中
	//(\\?(.*))?，表示子表达式出现0次或者1次。
	//(?:\\?(.*))?，子表达式出现0次或者1次，不提取?，提取(.*)到res中。
	//HTTP/1\\.[01],匹配版本号。
	//(?:\r\n|\n)?，同理表示匹配\r\n或者\n，0次或者1次，且不提取。
	regex r(pattern);
	bool ret = regex_match(str, res, r);
	if (ret)
	{
		cout << "匹配成功" << endl;
		for (auto e : res)
		{
            stringstream ssm;
            ssm << e;
            string s = e.str();
            cout << s << endl;
		}
	}
	else
	{
		cout << "匹配失败" << endl;
	}
	return 0;
}

说明：对正则表达式不太熟悉的C友可查看【C++进阶之路】C++11——正则表达式进行快速地入门和学习C++容器提供的对应接口。

涉及接口：

#include <algorithm>
std::stransform(oldbegin,oldend(),newposbegin,newposend,hder);
//将[begin,end)中的数据通过hder函数处理，放到newposbengin的位置，此处用于对请求方法统一转大写处理，因为可能发送的可能为小写。
  • 实现
//上下文处理的状态基，错误，初始，请求行处理完毕，消息头处理完毕，全部处理完毕。
typedef enum
{
    Error,
    Init,
    RevLine_Over,
    RevHeader_Over,
    Over,
}CxtStau;

class HttpContext
{
public:
    HttpContext(int reponse = 200)
    :_rep_stu(200),_stage(Init)
    {};
    CxtStau GetCxtStu()
    {
        return _stage;
    }
    int GetRepStu()
    {
        return _rep_stu;
    }
    HttpRequest GetRequest()
    {
        return _req;
    }
    void Recv_Parse(Buffer* buf)
    {
        switch (_stage)
        {
            case Init: if(!RevLine(buf)) break;
            case RevLine_Over: if(!RevHeader(buf)) break;
            case RevHeader_Over: if(!RevBody(buf)) break;
        }
    }
    void Reset()
    {
        _stage = Init;
        _rep_stu = 200;
        _req.Reset();
    }
private:
    //从接收缓存区中读取并解析请求行
    bool RevLine(Buffer* buf)
    {
        //从buf获取一行数据
        std::string line = buf->GetLine();
        //不到一行的数据大于MAX_LEN
        if(line.size() == 0 && buf->ReadableSize() > MAX_LEN)
        {
            _stage = Error;
            _rep_stu = 414; //URL太长了。
            return false;
        }
        //读取出来的一行数据大于MAX_LEN
        else if(line.size() > 0)
        {
            if(line.size() > MAX_LEN) 
            {
                _stage = Error;
                _rep_stu = 414; //URL太长了。
                return false;                
            }
            //处理数据
            else
            {
                //对请求行进行解析
                if(ParseLine(line))
                {
                    _stage = RevLine_Over;
                    return true;
                }
                else
                {
                    //解析出错
                    _stage = Error;
                    _rep_stu = 400;
                    return false;
                }
            }
        }
        //等待数据。
        return true;
    }
    bool ParseLine(std::string& line)
    {
        //1、使用正则表达式进行分析处理获取——请求方法 URL 请求参数 Http版本
        //2、对URL进行解码操作
        //3、对请求参数按照"&"分割，按照"="处理，获取key,val。
        std::smatch res;
        std::string pattern("(GET|HEAD|POST|PUT|DELETE) ([^?]*)(?:\\?(.*))? (HTTP/1\\.[01])(?:\r\n|\n)?");
        std::regex rx(pattern);
        bool ret = regex_match(line,res,rx);
        //第一个元素为line中的内容，剩余四个元素分别为请求方法，资源路径，参数，HTTP版本
        if(false == ret || res.size() != 5)//如果不为四个元素说明传输的数据有误。
        {
            return false;
        }
        else
        {	
        	//请求方法
            _req._method = res[1];    
            std::string& str = _req._method;
            std::transform(str.begin(),str.end(),str.begin(),::toupper);//GET可能为小写的需要转换为大写。
            //版本和资源路径
            _req._version = res[4];
            _req._source_dir = Util::UrlDecode(res[2],false);//资源路径不需要转空格
            //参数解析
            std::vector<std::string> arr;
            Util::Split(res[3],"&",&arr);//对参数行按照 & 进行分割
            for(auto& str : arr)
            {
                size_t pos = str.find("=");
                if(pos == std::string::npos)
                {
                    return false;                    
                }
                else
                {
                    //参数需要转空格
                    std::string key = Util::UrlDecode(str.substr(0,pos),true);
                    std::string val = Util::UrlDecode(str.substr(pos + 1),true);;
                    _req.SetParm(key,val);
                }
            }
        }
        return true;            
    }
    bool RevHeader(Buffer* buf)
    {
        if(_stage != RevLine_Over)
        {
            return false;
        }
        for(std::string line = buf->GetLine(); line != "\r\n" && line != "\n"; line = buf->GetLine())
        {
            if(line.size() == 0 && buf->ReadableSize() > MAX_LEN)
            {
                _stage = Error;
                _rep_stu = 414; //URL太长了。
                return false;
            }
            else if(line.size() > 0)
            {
                if(line.size() > MAX_LEN) 
                {
                    _stage = Error;
                    _rep_stu = 414; //URL太长了。
                    return false;                
                }
                else if(!ParseHeader(line))
                {
                    _stage = Error;
                    _rep_stu = 400;
                    return false;
                }
            }
        }
        _stage = RevHeader_Over;
        return true;
    }
    bool ParseHeader(std::string& line)
    {
        while(line.back() == '\r' || line.back() == '\n') line.pop_back();
        std::vector<std::string> kv;
        Util::Split(line, ": ",&kv);
        if(kv.size() != 2)
        {
            return false;
        }
        _req.SetHeader(kv[0],kv[1]);
        return true;
    }
    bool RevBody(Buffer* buf)
    {
        if(_stage != RevHeader_Over) return false;
        //1.获取正文长度。
        //2.判断数据是否足够读取。
        size_t len = _req.GetBodyLen();
        if(len > 0)
        {
            int rsz = _req._body.size();
            if(buf->Size() + rsz >= len)
            {
                _req._body.append(buf->Read(len - rsz));
                _stage = Over;
                return true;
            }
            else
            {
                _req._body.append(buf->Read());
                return true;
            }
        }
        else if(len == 0)
        {
            _stage = Over;
        }
        return true;
    }
private:
    CxtStau _stage;
    int _rep_stu;
    HttpRequest _req;
    enum{MAX_LEN = 8192};//一行的最大长度。
};
  • 从Buffer中获取除了正文以外的数据都是通过以行为单位进行获取和分析的，因此大于或者小于一行的数据不能过长，应有一个最长的长度，本项目中设置我8192长度，转化为单位为4KB。如果超过了此长度则认为数据非法，返回对应414响应码。
  • 在解析头部时需要将后面的尾巴——"\r\n"处理干净，以及在解析正文时需要根据头部提供的Content-Length获取正文长度，如果Buffer中的缓存区数据不够，将其所有数据放到上下文中，等待数据的到来。

2.4 Server

class HttpServer
{
public:
    using hder_t = std::function<void(const HttpRequest&,HttpResponse*)>;
    using router_t = std::vector<pair<std::string,hder_t>>;
    HttpServer(int port = 8000,int timout = 30):_svr(port)
    {
        _svr.EnRseTimout(timout);
        _svr.SetConCb(std::bind(&HttpServer::SetCxt,this,std::placeholders::_1));
        _svr.SetMsgCb(std::bind(&HttpServer::MsgHder,this,std::placeholders::_1,std::placeholders::_2));
        SetBaseDir();
    }
private:
    //通过ConPtr设置上下文
    void SetCxt(const ConPtr& con)
    {
        con->SetAnyCb(HttpContext());
    }
    //来自连接消息的解析和处理
    void MsgHder(const ConPtr& con,Buffer* buf)
    {
        while(buf->Size())
        {
            //获取上下文
            HttpContext* cxt = con->GetTxt()->get<HttpContext>();
            //接着进行处理获取更加完整的请求
            cxt->Recv_Parse(buf);
            HttpRequest req = cxt->GetRequest();
            HttpResponse rsp(cxt->GetRepStu());            
            //判断
            if(cxt->GetCxtStu() == Error)
            {
                WriteResponse(con,req,&rsp);
                //出错时要清空Buffer,之后不用再发数据了。
                buf->Clear();
                con->ShutDown();
                return;
            }
            else if(cxt->GetCxtStu() != Over)
            {
                return;
            }
            //路由处理
            Route(req,&rsp);
            //组装请求进行发送
            WriteResponse(con,req,&rsp);
            //重置上下文
            cxt->Reset();
            //判断是否要断开连接
            if(req.Close())
            {
                con->ShutDown();
            }
        }
    }
public:
    void SetBaseDir(std::string dir = "./wwwroot")
    {
        _base_dir = dir;
    }
    void SetHander(std::string method,std::string par,const hder_t& hder)
    {
        if(method == "HEAD" || method == "GET")
        {
            _get_rter.push_back({par,hder});
        }
        else if(method == "POST")
        {
            _post_rter.push_back({par,hder});
        }
        else if(method == "PUT")
        {
            _put_rter.push_back({par,hder});
        }
        else if(method == "DELETE")
        {
            _delete_rter.push_back({par,hder});
        }
    }
    void Start(int thread_cnt = 4)
    {
        _svr.Start(thread_cnt);
    }
private:
    //对请求处理方法进行分类
    void Route(HttpRequest& req,HttpResponse* rsp)
    {
        //判断是否是静态资源
        if(IsFileSource(req,rsp))
        {
            return FileHdr(req,rsp);
        }
        //分类进行动态的处理
        std::string method = req._method;
        if(method == "GET" || method == "HEAD")
        {
            return Dispacher(req,rsp,_get_rter);
        }
        else if(method == "PUT")
        {
            return Dispacher(req,rsp,_put_rter);
        }
        else if(method == "POST")
        {
            return Dispacher(req,rsp,_post_rter);
        }
        else if(method == "DELETE")
        {
            return Dispacher(req,rsp,_delete_rter);
        }
        else
        {
            rsp->_stau = 405; //Method Not Allowed
        }
    }
    //静态处理
    void FileHdr(HttpRequest& req,HttpResponse* rsp)
    {
        bool ret = Util::ReadFile(req._source_dir,&(rsp->_body));
        if(ret == true)
        {
            rsp->SetHeader("Content-Type",Util::Mine(req._source_dir));
        }
        else
        {
            ERROR_LOG("read file failed!!");
        }
    }
    bool IsFileSource(HttpRequest& req,HttpResponse* rsp)
    {
        std::string& sor_dir = req._source_dir;
        if(_base_dir != "" && (req._method == "GET" || req._method == "HEAD")&& Util::Valid(sor_dir))
        {
            std::string path = _base_dir + sor_dir;
            if(sor_dir == "/")
            {
                path += "index.html"; 
            }
            if(Util::IsRegular(path))
            {
                sor_dir = path;
                return true;
            } 
        }
        return false;
    }
    //动态处理
    void Dispacher(HttpRequest& req,HttpResponse* rsp,router_t& hders)
    {
        for(auto &kv : hders)
        {
            std::regex regx(kv.first);
            auto& hder = kv.second;
            bool ret = regex_match(req._source_dir,req._sch,regx);
            if(ret == true)
            {
                return hder(req,rsp);
            }
        }
        rsp->_stau = 404;//Not Found
    }
    //填充错误页面
    void ErrorHder(const HttpRequest& req,HttpResponse* rsp)
    {
        std::string filename = _base_dir + "/error.html";
        std::string content;
        Util::ReadFile(filename,&content);
        //错误页面放到响应中
        rsp->SetContent(content);
        return;
    }
    //对请求组织处理形成响应。
    void WriteResponse(const ConPtr& con,HttpRequest& req,HttpResponse* rsp)
    {
        //判断是否出错填充错误页面
        if(rsp->_stau > 400)
        {
            ErrorHder(req,rsp);
        }
        //完善头部字段: Connection Content-Length Content-Type Location
        if(req.Close())
        {
            rsp->SetHeader("Connection","close");
        }
        else
        {
            rsp->SetHeader("Connection","keep-alive");
        }
        if(!rsp->_body.empty())
        {
            if(!rsp->HasHeader("Content-Length"))
            {
                rsp->SetHeader("Content-Length",std::to_string(rsp->_body.size()));
            }
            if(!rsp->HasHeader("Content-Type"))
            {
                rsp->SetHeader("Content-Type","application/octet-stream");
            }
        }
        if(rsp->_is_redir){rsp->SetHeader("Location",rsp->_redir_url);}
        //组装Http协议响应信息

        //版本号 状态码 状态表示\r\n
        std::stringstream stm;
        stm << req._version << " " << rsp->_stau << " " << Util::Statu(rsp->_stau) << "\r\n";
        //头部信息
        for(auto& kv : rsp->_headers)
        {
            stm << kv.first << ": " << kv.second << "\r\n";
        }
        stm << "\r\n";
        //头部信息
        stm << rsp->_body;
        con->Send(stm.str());//不进行实际的发送只打开写事件监控
    }
private:
    router_t _put_rter;
    router_t _post_rter;
    router_t _get_rter;
    router_t _delete_rter;
    TcpServer _svr;
    std::string _base_dir;
};
  • HttpServer是一个最终的综合模块，通过服务器模块封装出来的TcpServer组件完成高效的IO处理，在初始化时将连接初始化和消息处理回调设置到其内部。上层只需关系资源的设置以及业务处理函数的管理。
  • 此模块内部通过设置上下文完成对连接的初始化，通过消息处理函数完成对连接业务地处理，业务处理主要包含静态的业务处理，即通过GET方法获取服务器的资源文件，即文件的读取，也可以通过路由表，即一个vector<string,函数回调>，动态地添加函数回调最终根据资源路径进行动态匹配，将结果放到HttpRequest的smath中，如果匹配成功则执行对应的回调，如果失败则接着继续匹配，直到遍历完为止。

业务处理图解：
在这里插入图片描述

尾序

 如果说上篇文章是包包子的话，那这篇文章就是用Http协议就是将包子包得再紧一些，那么最后就是将包子放到蒸笼里面蒸熟看包子最终的样子是好是坏，即让组件用起来看看怎么样，就要看最终测试环节了，不过这是下篇的内容，我们下篇再续。最后，我是舜华，期待与你的每一次相遇！下篇文章再见了！

舜华丶
关注
  • 8
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++应用实战项目开发视频教程
xiarilove的专栏
03-24 6253
C++应用实战项目:大并发高性能可伸缩服务器设计及开发(Http服务器、银行储蓄系统示例) 适合人群：初级 课时数量：49课时 用到技术：C++、服务器端技术 涉及项目：http服务器、银行储蓄系统 咨询qq：1840215592 《大并发服务器开发》目录列表如下: 01.大并发服务器架构介绍 02.大型网站架构演变过程 03.poll（一） 04.poll（二） 05.ep
【Mudo库】实战项目之简要介绍
Shun_Hua的博客
08-14 914
本文章主要是基于mudo库实现的高并发组件项目的基本介绍，内含模块的详细图解，希望对各位有所帮助。
【Mudo库】实战项目之服务器模块
最新发布
Shun_Hua的博客
08-18 553
本篇文章主要是衔接上篇文章，从代码的角度帮助各位读者进一步理解服务器模块，希望对各位有所帮助！
mudo服务器测试二
weixin_67595436的博客
03-19 324
业务处理超时测试 大文件传输测试 服务器性能压力测试说明
基于C语言实现的卡尔曼滤波算法 _C语言_mudo9h_
10-03
卡尔曼滤波是一种在噪声环境中估计动态系统状态的最优线性估计方法，广泛应用于导航、控制理论、信号处理和许多其他领域。这个压缩包文件包含了用C语言实现的卡尔曼滤波算法，对于想要深入理解和应用该算法的IT专业...
开源框架log4cpp和日志模块实现.pdf
09-09
【log4cpp开源框架详解与日志模块实现】 log4cpp是一个流行的开源日志框架，源自Java的日志处理项目log4j，它为C++程序员提供了灵活的日志记录功能。框架的核心理念是通过Category（分类）、Appender（输出器）、...
Linux多线程服务端编程：使用muduo+C网络库
08-06
Linux多线程服务端编程：使用muduo+C网络库.pdf Linux多线程服务端编程：使用muduo+C网络库.pdfLinux多线程服务端编程：使用muduo+C网络库.pdfLinux多线程服务端编程：使用muduo+C网络库.pdfLinux多线程服务端编程：...
《Linux多线程服务端编程：使用muduo C++网络库》.(陈硕).[PDF]
05-22
《Linux多线程服务端编程：使用muduo C++网络库》.(陈硕).[PDF] 源码地址：https://download.csdn.net/download/wumingzcj/10409650 源码地址：https://download.csdn.net/download/wumingzcj/10409650 ...
C++Network 源码系列.7z
07-25
网络编程源码系列，包括UNIX网络编程源码，Nginx源码，Mudo源码，Libevent源码，Boost标准库源码
http和websocket
m0_60274660的博客
08-14 422
网络通信的协议。
HTTP API 的幂等性（Idempotency）
galoiszhou的博客
08-15 507
HTTP API 的幂等性（Idempotency）是指同一个操作被执行多次，结果应当与执行一次时相同。这意味着，客户端可以在发生网络问题或其他错误时，安全地重试某个请求，而不会导致服务器状态的不一致或资源的重复创建。在设计HTTP API时，确保需要幂等的操作保持幂等性非常重要，这有助于提高系统的可靠性和容错性。
HTTP的认证方式
sinat_33536503的博客
08-15 1539
文章讨论了8种HTTP认证方式，提供了对HTTP认证方式的深入解析，同时还探讨了不同认证方式的适用场景和安全性。
基于 HTTP构建 YUM网络源
被生活耽误的旅行者
08-15 230
YUM光盘源默认只能本机使用，局域网其他服务器无法使用YUM光盘源，如果想使用的话，需要在每台服务器上构建YUM本地源，该方案在企业中不可取，所以需要构建HTTP局域网YUM源解决，可以通过CreateRepo创建本地YUM源端，repo即为Repository。/var/www/html/centos/中所有软件，YUM或者RPM安装HTTPWEB服务器，并启动httpd服务。拷贝/mnt/Packages目录下所有软件包至/var/www/html/centos/利用HTTP发布YUM本地源。
https跟http有什么区别？
kk_177803619的博客
08-08 2858
此外，HTTPS还通过数字证书机制验证了服务器的身份，防止了中间人攻击。在互联网的世界里，HTTP（HyperText Transfer Protocol，超文本传输协议）和HTTPS（HyperText Transfer Protocol Secure，安全超文本传输协议）是两种最为基础且广泛使用的网络协议，它们共同支撑着网络信息的传输与交换。然而，HTTP本身并不提供数据加密功能，所有传输的数据（包括用户输入的信息、浏览历史等）都是以明文形式在网络上传输，这使得数据在传输过程中容易被拦截、篡改或窃取。
http和https的区别
AndrewPerfect的博客
08-16 1013
HTTP适合那些不涉及敏感信息传输的普通网站，但在当今网络环境下，越来越多的网站已经转向使用HTTPS。HTTPS提供了加密的数据传输、安全的用户信息保护以及对用户身份的验证，是当前网站和应用程序的标准选择。
http request-01-XMLHttpRequest XHR 简单介绍
08-17 720
遵循这些最佳实践可以帮助你在使用时编写更高效、可靠和易于维护的代码。虽然fetchAPI 提供了更现代的接口，但了解和掌握仍然在许多情况下很重要，尤其是在处理兼容性问题时。
检测到目标URL存在http host头攻击漏洞
ruanjian_kj的博客
08-16 267
nginx 的 default_server 指令可以定义默认的 server 去处理一些没有匹配到 server_name 的请求，如果没有显式定义，则会选取第一个定义的 server 作为 default_server。若请求不是指定的url，一律返回403。
HTTP/1.1
2202_75483664的博客
08-15 811
Content-Type: application/x-www-form-urlencoded -请求体内容类型[服务器根据类型解析请求体参数]重定向，当响应码为302时，表示服务器要求浏览器重新再发一个请求，服务器会发送一个响应头Location指定新请求的URL地址；- 当前页面的上一个页面的路径[当前页面通过哪个页面跳转过来的]： 可以通过此路径跳转回上一个页面， 广告计费，防止盗链。-请求协议的自动升级[http的请求，服务器却是https的，浏览器自动会将请求协议升级为https的]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值