muduo库http源码分析

最新推荐文章于 2023-04-23 22:44:41 发布
最新推荐文章于 2023-04-23 22:44:41 发布
阅读量799 收藏
点赞数
文章标签： http 网络协议 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_28697845/article/details/123087767
版权

http request

HTTP请求包含：request line + header + body （header分为普通报头，请求报头与实体报头） header与body之间有一空行（CRLF）

请求方法有： Get, Post, Head, Put, Delete等 协议版本1.0、1.1

常用请求头

Accept：浏览器可接受的媒体（MIME）类型；

Accept-Language：浏览器所希望的语言种类

Accept-Encoding：浏览器能够解码的编码方法，如gzip，deflate等

User-Agent：告诉HTTP服务器， 客户端使用的操作系统和浏览器的名称和版本

Connection：表示是否需要持久连接，Keep-Alive表示长连接，close表示短连接

GET / HTTP/1.1

Accept: image/jpeg, application/x-ms-application, image/gif, application/xaml+xml, image/pjpeg, application/x-ms-xbap, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*

Accept-Language: zh-CN

User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; Tablet PC 2.0)

Accept-Encoding: gzip, deflate

Host: 192.168.159.188:8000

Connection: Keep-Alive

http response

status line + header + body （header分为普通报头，响应报头与实体报头）

header与body之间有一空行（CRLF）

状态响应码

1XX  提示信息 - 表示请求已被成功接收，继续处理

2XX  成功 - 表示请求已被成功接收，理解，接受

3XX  重定向 - 要完成请求必须进行更进一步的处理

4XX  客户端错误 -  请求有语法错误或请求无法实现

5XX  服务器端错误 -   服务器执行一个有效请求失败

HTTP/1.1 200 OK
Content-Length: 112
Connection: Keep-Alive
Content-Type: text/html
Server: Muduo

<html><head><title>This is title</title></head><body><h1>Hello</h1>Now is 20130611 02:14:31.518462</body></html>

HttpRequest：http请求类封装

#ifndef MUDUO_NET_HTTP_HTTPREQUEST_H
#define MUDUO_NET_HTTP_HTTPREQUEST_H

#include <muduo/base/copyable.h>
#include <muduo/base/Timestamp.h>
#include <muduo/base/Types.h>

#include <map>
#include <assert.h>
#include <stdio.h>

namespace muduo
{
namespace net
{

class HttpRequest : public muduo::copyable
{
 public:
  enum Method
  {
    kInvalid, kGet, kPost, kHead, kPut, kDelete // http 方法类型，当前只支持这些
  };
  enum Version
  {
    kUnknown, kHttp10, kHttp11
  };

  HttpRequest()
    : method_(kInvalid),
      version_(kUnknown)
  {
  }

  void setVersion(Version v)
  {
    version_ = v;
  }

  Version getVersion() const
  { return version_; }

  bool setMethod(const char* start, const char* end)
  {
    assert(method_ == kInvalid);
    string m(start, end);
    if (m == "GET")
    {
      method_ = kGet;
    }
    else if (m == "POST")
    {
      method_ = kPost;
    }
    else if (m == "HEAD")
    {
      method_ = kHead;
    }
    else if (m == "PUT")
    {
      method_ = kPut;
    }
    else if (m == "DELETE")
    {
      method_ = kDelete;
    }
    else
    {
      method_ = kInvalid;
    }
    return method_ != kInvalid;
  }

  Method method() const
  { return method_; }

  const char* methodString() const
  {
    const char* result = "UNKNOWN";
    switch(method_)
    {
      case kGet:
        result = "GET";
        break;
      case kPost:
        result = "POST";
        break;
      case kHead:
        result = "HEAD";
        break;
      case kPut:
        result = "PUT";
        break;
      case kDelete:
        result = "DELETE";
        break;
      default:
        break;
    }
    return result;
  }

  void setPath(const char* start, const char* end)
  {
    path_.assign(start, end);
  }

  const string& path() const
  { return path_; }

  void setReceiveTime(Timestamp t)
  { receiveTime_ = t; }

  Timestamp receiveTime() const
  { return receiveTime_; }

  void addHeader(const char* start, const char* colon, const char* end)
  {
    string field(start, colon);		// header域
    ++colon;
    // 去除左空格
    while (colon < end && isspace(*colon))
    {
      ++colon;
    }
    string value(colon, end);		// header值
    // 去除右空格
    while (!value.empty() && isspace(value[value.size()-1]))
    {
      value.resize(value.size()-1);
    }
    headers_[field] = value;
  }

  string getHeader(const string& field) const
  {
    string result;
    std::map<string, string>::const_iterator it = headers_.find(field);
    if (it != headers_.end())
    {
      result = it->second;
    }
    return result;
  }

  const std::map<string, string>& headers() const
  { return headers_; }

  void swap(HttpRequest& that)
  {
    std::swap(method_, that.method_);
    path_.swap(that.path_);
    receiveTime_.swap(that.receiveTime_);
    headers_.swap(that.headers_);
  }

 private:
  Method method_;		// 请求方法
  Version version_;		// 协议版本1.0/1.1
  string path_;			// 请求路径
  Timestamp receiveTime_;	// 请求时间
  std::map<string, string> headers_;	// header列表
};

}
}

#endif  // MUDUO_NET_HTTP_HTTPREQUEST_H

HttpResponse：http响应类封装

#ifndef MUDUO_NET_HTTP_HTTPREQUEST_H
#define MUDUO_NET_HTTP_HTTPREQUEST_H

#include <muduo/base/copyable.h>
#include <muduo/base/Timestamp.h>
#include <muduo/base/Types.h>

#include <map>
#include <assert.h>
#include <stdio.h>

namespace muduo
{
namespace net
{

class HttpRequest : public muduo::copyable
{
 public:
  enum Method
  {
    kInvalid, kGet, kPost, kHead, kPut, kDelete
  };
  enum Version
  {
    kUnknown, kHttp10, kHttp11
  };

  HttpRequest()
    : method_(kInvalid),
      version_(kUnknown)
  {
  }

  void setVersion(Version v)
  {
    version_ = v;
  }

  Version getVersion() const
  { return version_; }

  bool setMethod(const char* start, const char* end)
  {
    assert(method_ == kInvalid);
    string m(start, end);
    if (m == "GET")
    {
      method_ = kGet;
    }
    else if (m == "POST")
    {
      method_ = kPost;
    }
    else if (m == "HEAD")
    {
      method_ = kHead;
    }
    else if (m == "PUT")
    {
      method_ = kPut;
    }
    else if (m == "DELETE")
    {
      method_ = kDelete;
    }
    else
    {
      method_ = kInvalid;
    }
    return method_ != kInvalid;
  }

  Method method() const
  { return method_; }

  const char* methodString() const
  {
    const char* result = "UNKNOWN";
    switch(method_)
    {
      case kGet:
        result = "GET";
        break;
      case kPost:
        result = "POST";
        break;
      case kHead:
        result = "HEAD";
        break;
      case kPut:
        result = "PUT";
        break;
      case kDelete:
        result = "DELETE";
        break;
      default:
        break;
    }
    return result;
  }

  void setPath(const char* start, const char* end)
  {
    path_.assign(start, end);
  }

  const string& path() const
  { return path_; }

  void setReceiveTime(Timestamp t)
  { receiveTime_ = t; }

  Timestamp receiveTime() const
  { return receiveTime_; }

  void addHeader(const char* start, const char* colon, const char* end)
  {
    string field(start, colon);		// header域
    ++colon;
    // 去除左空格
    while (colon < end && isspace(*colon))
    {
      ++colon;
    }
    string value(colon, end);		// header值
    // 去除右空格
    while (!value.empty() && isspace(value[value.size()-1]))
    {
      value.resize(value.size()-1);
    }
    headers_[field] = value;
  }

  string getHeader(const string& field) const
  {
    string result;
    std::map<string, string>::const_iterator it = headers_.find(field);
    if (it != headers_.end())
    {
      result = it->second;
    }
    return result;
  }

  const std::map<string, string>& headers() const
  { return headers_; }

  void swap(HttpRequest& that)
  {
    std::swap(method_, that.method_);
    path_.swap(that.path_);
    receiveTime_.swap(that.receiveTime_);
    headers_.swap(that.headers_);
  }

 private:
  Method method_;		// 请求方法
  Version version_;		// 协议版本1.0/1.1
  string path_;			// 请求路径
  Timestamp receiveTime_;	// 请求时间
  std::map<string, string> headers_;	// header列表
};

}
}

#endif  // MUDUO_NET_HTTP_HTTPREQUEST_H

#include <muduo/net/http/HttpResponse.h>
#include <muduo/net/Buffer.h>

#include <stdio.h>

using namespace muduo;
using namespace muduo::net;

void HttpResponse::appendToBuffer(Buffer* output) const
{
  char buf[32];
  // 添加响应头
  snprintf(buf, sizeof buf, "HTTP/1.1 %d ", statusCode_);
  output->append(buf);
  output->append(statusMessage_);
  output->append("\r\n");

  if (closeConnection_)
  {
    // 如果是短连接，不需要告诉浏览器Content-Length，浏览器也能正确处理
    output->append("Connection: close\r\n");
  }
  else
  {
    snprintf(buf, sizeof buf, "Content-Length: %zd\r\n", body_.size());	// 实体长度
    output->append(buf);
    output->append("Connection: Keep-Alive\r\n");
  }

  // header列表
  for (std::map<string, string>::const_iterator it = headers_.begin();
       it != headers_.end();
       ++it)
  {
    output->append(it->first);
    output->append(": ");
    output->append(it->second);
    output->append("\r\n");
  }

  output->append("\r\n");	// header与body之间的空行
  output->append(body_);
}

HttpContext：http协议解析类

#ifndef MUDUO_NET_HTTP_HTTPCONTEXT_H
#define MUDUO_NET_HTTP_HTTPCONTEXT_H

#include <muduo/base/copyable.h>

#include <muduo/net/http/HttpRequest.h>

namespace muduo
{
namespace net
{

class HttpContext : public muduo::copyable
{
 public:
  enum HttpRequestParseState
  {
    kExpectRequestLine,
    kExpectHeaders,
    kExpectBody,
    kGotAll,
  };

  HttpContext()
    : state_(kExpectRequestLine)
  {
  }

  // default copy-ctor, dtor and assignment are fine

  bool expectRequestLine() const
  { return state_ == kExpectRequestLine; }

  bool expectHeaders() const
  { return state_ == kExpectHeaders; }

  bool expectBody() const
  { return state_ == kExpectBody; }

  bool gotAll() const
  { return state_ == kGotAll; }

  void receiveRequestLine()
  { state_ = kExpectHeaders; }

  void receiveHeaders()
  { state_ = kGotAll; }  // FIXME

  // 重置HttpContext状态
  void reset()
  {
    state_ = kExpectRequestLine;
    HttpRequest dummy;
    request_.swap(dummy);
  }

  const HttpRequest& request() const
  { return request_; }

  HttpRequest& request()
  { return request_; }

 private:
  HttpRequestParseState state_;		// 请求解析状态
  HttpRequest request_;				// http请求
};

}
}

#endif  // MUDUO_NET_HTTP_HTTPCONTEXT_H

HttpServer：http服务器类封装

#ifndef MUDUO_NET_HTTP_HTTPSERVER_H
#define MUDUO_NET_HTTP_HTTPSERVER_H

#include <muduo/net/TcpServer.h>
#include <boost/noncopyable.hpp>

namespace muduo
{
namespace net
{

class HttpRequest;
class HttpResponse;

/// A simple embeddable HTTP server designed for report status of a program.
/// It is not a fully HTTP 1.1 compliant server, but provides minimum features
/// that can communicate with HttpClient and Web browser.
/// It is synchronous, just like Java Servlet.
class HttpServer : boost::noncopyable
{
 public:
  typedef boost::function<void (const HttpRequest&,
                                HttpResponse*)> HttpCallback;

  HttpServer(EventLoop* loop,
             const InetAddress& listenAddr,
             const string& name);

  ~HttpServer();  // force out-line dtor, for scoped_ptr members.

  /// Not thread safe, callback be registered before calling start().
  void setHttpCallback(const HttpCallback& cb)
  {
    httpCallback_ = cb;
  }

  void setThreadNum(int numThreads)
  {
    server_.setThreadNum(numThreads);
  }

  void start();

 private:
  void onConnection(const TcpConnectionPtr& conn);
  void onMessage(const TcpConnectionPtr& conn,
                 Buffer* buf,
                 Timestamp receiveTime);
  void onRequest(const TcpConnectionPtr&, const HttpRequest&);

  TcpServer server_;
  HttpCallback httpCallback_;	// 在处理http请求（即调用onRequest）的过程中回调此函数，对请求进行具体的处理
};

}
}

#endif  // MUDUO_NET_HTTP_HTTPSERVER_H

#include <muduo/net/http/HttpServer.h>

#include <muduo/base/Logging.h>
#include <muduo/net/http/HttpContext.h>
#include <muduo/net/http/HttpRequest.h>
#include <muduo/net/http/HttpResponse.h>

#include <boost/bind.hpp>

using namespace muduo;
using namespace muduo::net;

namespace muduo
{
namespace net
{
namespace detail
{

// FIXME: move to HttpContext class
bool processRequestLine(const char* begin, const char* end, HttpContext* context)
{
  bool succeed = false;
  const char* start = begin;
  const char* space = std::find(start, end, ' ');
  HttpRequest& request = context->request();
  if (space != end && request.setMethod(start, space))		// 解析请求方法
  {
    start = space+1;
    space = std::find(start, end, ' ');
    if (space != end)
    {
      request.setPath(start, space);	// 解析PATH
      start = space+1;
      succeed = end-start == 8 && std::equal(start, end-1, "HTTP/1.");
      if (succeed)
      {
        if (*(end-1) == '1')
        {
          request.setVersion(HttpRequest::kHttp11);		// HTTP/1.1
        }
        else if (*(end-1) == '0')
        {
          request.setVersion(HttpRequest::kHttp10);		// HTTP/1.0
        }
        else
        {
          succeed = false;
        }
      }
    }
  }
  return succeed;
}

// FIXME: move to HttpContext class
// return false if any error
bool parseRequest(Buffer* buf, HttpContext* context, Timestamp receiveTime)
{
  bool ok = true;
  bool hasMore = true;
  while (hasMore)
  {
    if (context->expectRequestLine())	// 处于解析请求行状态
    {
      const char* crlf = buf->findCRLF();
      if (crlf)
      {
        ok = processRequestLine(buf->peek(), crlf, context);	// 解析请求行
        if (ok)
        {
          context->request().setReceiveTime(receiveTime);		// 设置请求时间
          buf->retrieveUntil(crlf + 2);		// 将请求行从buf中取回，包括\r\n
          context->receiveRequestLine();	// 将HttpContext状态改为kExpectHeaders
        }
        else
        {
          hasMore = false;
        }
      }
      else
      {
        hasMore = false;
      }
    }
    else if (context->expectHeaders())		// 解析header
    {
      const char* crlf = buf->findCRLF();
      if (crlf)
      {
        const char* colon = std::find(buf->peek(), crlf, ':');		//冒号所在位置
        if (colon != crlf)
        {
          context->request().addHeader(buf->peek(), colon, crlf);
        }
        else
        {
          // empty line, end of header
          context->receiveHeaders();		// HttpContext将状态改为kGotAll
          hasMore = !context->gotAll();
        }
        buf->retrieveUntil(crlf + 2);		// 将header从buf中取回，包括\r\n
      }
      else
      {
        hasMore = false;
      }
    }
    else if (context->expectBody())			// 当前还不支持请求中带body
    {
      // FIXME:
    }
  }
  return ok;
}

void defaultHttpCallback(const HttpRequest&, HttpResponse* resp)
{
  resp->setStatusCode(HttpResponse::k404NotFound);
  resp->setStatusMessage("Not Found");
  resp->setCloseConnection(true);
}

}
}
}

HttpServer::HttpServer(EventLoop* loop,
                       const InetAddress& listenAddr,
                       const string& name)
  : server_(loop, listenAddr, name),
    httpCallback_(detail::defaultHttpCallback)
{
  server_.setConnectionCallback(
      boost::bind(&HttpServer::onConnection, this, _1));
  server_.setMessageCallback(
      boost::bind(&HttpServer::onMessage, this, _1, _2, _3));
}

HttpServer::~HttpServer()
{
}

void HttpServer::start()
{
  LOG_WARN << "HttpServer[" << server_.name()
    << "] starts listenning on " << server_.hostport();
  server_.start();
}

void HttpServer::onConnection(const TcpConnectionPtr& conn)
{
  if (conn->connected())
  {
    conn->setContext(HttpContext());	// TcpConnection与一个HttpContext绑定
  }
}

void HttpServer::onMessage(const TcpConnectionPtr& conn,
                           Buffer* buf,
                           Timestamp receiveTime)
{
  HttpContext* context = boost::any_cast<HttpContext>(conn->getMutableContext());

  if (!detail::parseRequest(buf, context, receiveTime))
  {
    conn->send("HTTP/1.1 400 Bad Request\r\n\r\n");
    conn->shutdown();
  }

  // 请求消息解析完毕
  if (context->gotAll())
  {
    onRequest(conn, context->request());
    context->reset();		// 本次请求处理完毕，重置HttpContext，适用于长连接
  }
}

void HttpServer::onRequest(const TcpConnectionPtr& conn, const HttpRequest& req)
{
  const string& connection = req.getHeader("Connection");
  bool close = connection == "close" ||
    (req.getVersion() == HttpRequest::kHttp10 && connection != "Keep-Alive");
  HttpResponse response(close);
  httpCallback_(req, &response);
  Buffer buf;
  response.appendToBuffer(&buf);
  conn->send(&buf);
  if (response.closeConnection())
  {
    conn->shutdown();
  }
}

houcaihua
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详细muduo的使用(一)——源码分析(架构和概念)
康Code的博客
05-03 4043
目录 muduo的架构和概念 一个简单的例子 连接的建立 消息的读取 消息的发送 为什么要移除可写事件 连接的断开 runInLoop的实现 为什么要唤醒EventLoop wakeup是怎么实现的 doPendingFunctors的实现 muduo的线程模型 主从reactor模式 业务线程池 总结 参考 muduo的架构和概念 muduo中类的职责和...
muduo日志库原理以及源码分析
m0_70418130的博客
10-11 622
muduo的这些特点使得其作为高性能日志库被广泛使用。
muduo网络库base详细源码分析
m0_47178337的博客
01-04 1063
1 muduo网络库的目录结构 /muduo$ tree ./ -L 2 ./ ├── BUILD.bazel ├── build.sh ├── ChangeLog ├── ChangeLog2 ├── CMakeLists.txt ├── contrib │?? ├── CMakeLists.txt │?? ├── hiredis │?? └── thrift ├── muduo ├── README └── WORKSPACE …… muduo库主体代码 ├── muduo │ ├── base
Muduo源码剖析--整体架构
Birate的博客
04-09 935
git: GitHub - chenshuo/muduo: Event-driven network library for multi-threaded Linux server in C++11git clone https://github.com/chenshuo/muduo.git安装依赖库:编译:如何在自己的程序中使用muduomuduo是静态链接的c++程序库， 使用muduo的时候，只需要设置好头文件的路径和库文件路径并链接相应的静态库文件(0lmuduo_net -lmuduo_base)
Muduo源码剖析
YanWenCheng_的博客
04-23 993
muduo源码剖析
muduo源码总结
qq_34489443的博客
09-28 951
1.对Reactor模式的理解 个人理解Reactor（反应堆）模型，就是用一个线程来监听不止一个文件描述符，每当一个文件描述符产生被关注的事件时，就会分发给其他线程或者自己来解决这个事件。其核心我觉得就是使用epoll实现多路复用，也就是一个线程可以实现多个文件描述符的监听。 2.muduo的模式总结 muduo的编程模型称之为one loop per thread，我觉得也可以称之为Mu...
muduo C++网络库 源码（linux）
05-12
《muduo C++网络库源码解析》 muduo是一个开源的C++网络库，专为Linux平台设计，其主要目标是提供一个高效、稳定、易用的多线程网络库，适用于开发高性能的服务器应用。这个库由淘宝的一位资深工程师Chen Jie（网名...
完整muduo网络库
04-01
`muduo-master`目录包含了完整的muduo网络库源码，包括头文件、源文件、示例程序和测试用例。通过阅读和分析这些代码，开发者可以更好地理解muduo的设计思想和实现细节。 总结，muduo网络库是一个强大的工具，它为...
muduo库reactor类结构分析
03-10
用来分析muduo的reactor结构，怕自己忘了，写个思维导图总结一下
muduo库手册
11-18
感觉不错，分享一下，它的使用手册，希望它对你有帮助
muduo网络库
12-01
**muduo网络库** muduo网络库是一款专为C++设计的高性能、线程安全的网络库，尤其适用于开发高性能服务器应用。它由知名C++开发者陈硕（Chen Shuo）创建，旨在提供一种高效、简洁的处理网络I/O的方式。muduo网络库...
muduo 木铎
11-18
多线程开发，很不错的库，开源库，中国人写的。学习和使用都不错的资源
muduo源码注释（非常详细）
10-10
个人在阅读muduo源码时，做的注释，非常详细，可以配合我的博客一起阅读。
muduo源码分析(一)
热门推荐
专注于网络编程,游戏后台,高并发
06-14 2万+
muduo是个基于现代C++高效的高并发网络库，他依赖boost库，由陈硕大神编写，更多详情介绍，请看点击打开链接 muduo代码结构比较清晰易懂，各个细节处理的非常完美，是一个非常值得学习的开源库。基于他是个网络库，开篇我剖析他的网络相关部分的结果，各个类的继承，调用关系。 网络服务器要处理的对象无外乎，监听者TcpServer，连接接收者Acceptor，连接者TcpConnection等...
【muduo源码剖析】Thread/ThreadPool源码解析
weixin_46272577的博客
09-20 432
Thread/ThreadPool源码解析
muduo网络库学习之muduo_http 库涉及到的类
Meditation
11-13 5677
1、http request： request line + header + body （header分为普通报头，请求报头与实体报头） header与body之间有一空行（CRLF） 请求方法有： Get, Post, Head, Put, Delete等 协议版本1.0、1.1 常用请求头 Accept：浏览器可接受的
从零开始学写HTTP服务器（六）使用muduo网络库
上善若水
12-28 8030
muduo实现简单的HttpServer
muduo的性能测试引发的思考
m0_61815263的博客
04-23 264
muduo自带的http服务器性能测试引发的多线程思考。
muduo学习笔记：net部分之Http-协议简介
热爱生活，忠于自己
09-06 556
HTTP协议（HyperText Transfer Protocol，超文本传输协议）目前是互联网上应用最为广泛的一种网络传输协议，基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等），最新已经发展到基于UDP/QUICK的HTTP/3版本，目前协议版本多使用1.1。另外，本文不介绍HTTPS基于SSL/TLS加密。 HTTP协议是基于文本的，也就是TCP传输主要是文本（数据部分可能是二进制数据），HTTP消息分为请求Request、响应Response两种。HTTP的请求由客户端
boost库与muduo库有什么区别
最新发布
09-10
### 回答1： Boost库是一个跨平台的C++程序库，提供了许多常用的C++工具和类。...Boost库是一个通用性较强的C++扩展库，而muduo库则是一个专注于网络编程的性能优化库。选择使用哪个库取决于具体的需求和开发目标。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值