目录

0.框架 && 前言1.TcpServer类1.功能2.类设计

2.HttpServer类1.功能2.类设计

3.Request类 && Response类1.功能2.Request类设计3.Response类设计

4.EndPoint类1.功能2.类设计

5.Task类1.功能2.类设计

6.ThreadPool类1.功能2.类设计

0.框架 && 前言

程序main()函数如下

<code>void Usage(std::string proc)

{ -- -->

std::cout << "Usage:\n\t" << proc << " Port" << std::endl;

}

int main(int argc, char *argv[])

{

if(argc != 2)

{

Usage(argv[0]);

exit(4);

}

std::unique_ptr<HttpServer> httpServer(new HttpServer(atoi(argv[1])));

httpServer->Init();

httpServer->Loop();

return 0;

}

本项目将分模块设计，主要包含以下模块注意：本篇只放函数声明

1.TcpServer类

1.功能

主要负责底层的TCP通信将其设计为单例模式，作为一个组件，置入HTTPServer中

2.类设计

static const uint16_t PORT = 8090;

static const int BACKLOG = 128;

// 单例 -- 饿汉模式

class TcpServer

{

public:

static TcpServer* GetInstance(uint16_t port = PORT)

{ }

void Init()

{ }

void Socket()

{ }

void Bind()

{ }

void Listen()

{ }

int Sock()

{ }

~TcpServer()

{ }

private:

TcpServer(uint16_t port)

: _port(port)

, _listenSock(-1)

{ }

TcpServer(const TcpServer&) = delete;

private:

uint16_t _port;

int _listenSock;

static TcpServer* svr;

};

TcpServer* TcpServer::svr = nullptr;

2.HttpServer类

1.功能

主要负责HTTP协议的通信其中主要包括以下模块

TcpServerThreadPoolTaskQueue

2.类设计

class HttpServer

{

public:

HttpServer(int port = PORT)

: _port(port)

, _stop(false)

{ }

void Init()

{ }

void Loop(int threadNum = THREAD_POOL_NUM)

{ }

private:

uint16_t _port;

bool _stop;

};

3.Request类 && Response类

1.功能

Request类负责存储接收到的请求及解析结果ReSponse类用来构建响应

2.Request类设计

struct HttpRequest

{

std::string request_line;

std::vector<std::string> request_header;

std::string blank;

std::string request_body;

// 解析结果

std::string method;

std::string uri;

std::string version;

std::unordered_map<std::string, std::string> headerMap;

size_t content_length;

std::string path;

std::string suffix;

std::string arg;

bool cgi;

HttpRequest()

: content_length(0)

, cgi(false)

{ }

};

3.Response类设计

struct HttpResponse

{

std::string status_line;

std::vector<std::string> response_header;

std::string blank;

std::string response_body;

int status_code;

int fd;

int fSize;

HttpResponse()

: status_code(OK)

, fd(-1)

, blank(LINE_END)

{ }

};

4.EndPoint类

1.功能

负责两端业务处理，主要包括以下功能

读取请求、分析请求、构建响应、IO通信该类为本项目主要设计方向

2.类设计

class EndPoint

{

public:

EndPoint(int sock)

: _sock(sock)

, _stop(false)

{ }

~EndPoint()

{ }

void RecvRequest()

{ }

void BuildResponse()

{ }

void SendResponse()

{ }

bool IsStop()

{ }

private:

bool RecvRequestLine()

{ }

bool RecvRequestHeader()

{ }

void ParseRequestLine()

{ }

void ParseRequestHeader()

{ }

bool IsRecvRequestBody()

{ }

bool RecvRequestBody()

{ }

int ProcessNonCgi()

{ }

int ProcessCgi()

{ }

void BuildResponseHelper()

{ }

void BuildOKResponse()

{ }

void HandlerError(std::string page)

{ }

private:

int _sock;

bool _stop;

HttpRequest _request;

HttpResponse _response;

};

5.Task类

1.功能

将HTTP请求构建成一个任务，以便ThreadPool管理任务队列，一定程度上和ThreadPool一起缓解了服务器压力

2.类设计

class Task

{

public:

void ProcessOn()

{ }

Task()

{ }

Task(int sock)

: _sock(sock)

{ }

~Task()

{ }

private:

int _sock;

CallBack _handler; // 设置回调

};

6.ThreadPool类

1.功能

线程池，分配任务给各线程，使其处理请求主要解决问题：

大量链接过来导致服务器内部进程或者线程暴增，进而导致服务器效率严重降低或者挂掉节省链接请求到来时，创建线程的时间成本

提前创建好了一批线程，来任务时处理任务，没有任务时，让线程休眠 让服务器的效率在一个恒定的稳定区间内

线程个数不增多，CPU调度成本基本不变

2.类设计

static const int THREAD_POOL_NUM = 10;

// 单例模式

class ThreadPool

{

public:

static ThreadPool *GetInstance(int num = THREAD_POOL_NUM)

{ }

static void *ThreadRoutine(void *args)

{ }

bool Init()

{ }

void Push(const Task& task) // in

{ }

void Pop(Task& task) // out

{ }

void ThreadWait()

{ }

void ThreadWakeUp()

{ }

bool TaskQueueIsEmpty()

{ }

void Lock()

{ }

void Unlock()

{ }

bool IsStop()

{ }

~ThreadPool()

{ }

private:

ThreadPool(int num = THREAD_POOL_NUM)

: _num(num), _stop(false)

{ }

ThreadPool(const ThreadPool &) = delete;

private:

int _num;

bool _stop;

std::queue<Task> _taskQueue;

pthread_mutex_t _mtx;

pthread_cond_t _cond;

static ThreadPool *_tp;

};

ThreadPool* ThreadPool::_tp = nullptr;